![[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 / i386|
Return to pcb.c CVS log | Up to [Apple XNU] / XNU / osfmk / i386 |
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: * Mach Operating System
27: * Copyright (c) 1991,1990 Carnegie Mellon University
28: * All Rights Reserved.
29: *
30: * Permission to use, copy, modify and distribute this software and its
31: * documentation is hereby granted, provided that both the copyright
32: * notice and this permission notice appear in all copies of the
33: * software, derivative works or modified versions, and any portions
34: * thereof, and that both notices appear in supporting documentation.
35: *
36: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
37: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
38: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
39: *
40: * Carnegie Mellon requests users of this software to return to
41: *
42: * Software Distribution Coordinator or [email protected]
43: * School of Computer Science
44: * Carnegie Mellon University
45: * Pittsburgh PA 15213-3890
46: *
47: * any improvements or extensions that they make and grant Carnegie Mellon
48: * the rights to redistribute these changes.
49: */
50:
51: #include <cpus.h>
52: #include <mach_rt.h>
53: #include <mach_debug.h>
54: #include <mach_ldebug.h>
55:
56: #include <mach/kern_return.h>
57: #include <mach/thread_status.h>
58: #include <mach/vm_param.h>
59: #include <mach/rpc.h>
60:
61: #include <kern/counters.h>
62: #include <kern/mach_param.h>
63: #include <kern/task.h>
64: #include <kern/thread.h>
65: #include <kern/thread_act.h>
66: #include <kern/thread_swap.h>
67: #include <kern/sched_prim.h>
68: #include <kern/misc_protos.h>
69: #include <kern/assert.h>
70: #include <kern/spl.h>
71: #include <ipc/ipc_port.h>
72: #include <vm/vm_kern.h>
73: #include <vm/pmap.h>
74:
75: #include <i386/thread.h>
76: #include <i386/eflags.h>
77: #include <i386/proc_reg.h>
78: #include <i386/seg.h>
79: #include <i386/tss.h>
80: #include <i386/user_ldt.h>
81: #include <i386/fpu.h>
82: #include <i386/iopb_entries.h>
83:
84: /*
85: * Maps state flavor to number of words in the state:
86: */
87: unsigned int state_count[] = {
88: /* FLAVOR_LIST */ 0,
89: i386_NEW_THREAD_STATE_COUNT,
90: i386_FLOAT_STATE_COUNT,
91: i386_ISA_PORT_MAP_STATE_COUNT,
92: i386_V86_ASSIST_STATE_COUNT,
93: i386_REGS_SEGS_STATE_COUNT,
94: i386_THREAD_SYSCALL_STATE_COUNT,
95: /* THREAD_STATE_NONE */ 0,
96: i386_SAVED_STATE_COUNT,
97: };
98:
99: /* Forward */
100:
101: void act_machine_throughcall(thread_act_t thr_act);
102: extern thread_t Switch_context(
103: thread_t old,
104: void (*cont)(void),
105: thread_t new);
106: extern void Thread_continue(void);
107: extern void Load_context(
108: thread_t thread);
109:
110: /*
111: * consider_machine_collect:
112: *
113: * Try to collect machine-dependent pages
114: */
115: void
116: consider_machine_collect()
117: {
118: }
119:
120: /*
121: * machine_kernel_stack_init:
122: *
123: * Initialize a kernel stack which has already been
124: * attached to its thread_activation.
125: */
126:
127: void
128: machine_kernel_stack_init(
129: thread_t thread,
130: void (*continuation)(void))
131: {
132: thread_act_t thr_act = thread->top_act;
133: vm_offset_t stack;
134:
135: assert(thr_act);
136: stack = thread->kernel_stack;
137: assert(stack);
138:
139: #if MACH_ASSERT
140: if (watchacts & WA_PCB) {
141: printf("machine_kernel_stack_init(thr=%x,stk=%x,cont=%x)\n",
142: thread,stack,continuation);
143: printf("\tstack_iks=%x, stack_iel=%x\n",
144: STACK_IKS(stack), STACK_IEL(stack));
145: }
146: #endif /* MACH_ASSERT */
147:
148: /*
149: * We want to run continuation, giving it as an argument
150: * the return value from Load_context/Switch_context.
151: * Thread_continue takes care of the mismatch between
152: * the argument-passing/return-value conventions.
153: * This function will not return normally,
154: * so we don`t have to worry about a return address.
155: */
156: STACK_IKS(stack)->k_eip = (int) Thread_continue;
157: STACK_IKS(stack)->k_ebx = (int) continuation;
158: STACK_IKS(stack)->k_esp = (int) STACK_IEL(stack);
159:
160: /*
161: * Point top of kernel stack to user`s registers.
162: */
163: STACK_IEL(stack)->saved_state = &thr_act->mact.pcb->iss;
164: }
165:
166:
167: #if NCPUS > 1
168: #define curr_gdt(mycpu) (mp_gdt[mycpu])
169: #define curr_ktss(mycpu) (mp_ktss[mycpu])
170: #else
171: #define curr_gdt(mycpu) (gdt)
172: #define curr_ktss(mycpu) (&ktss)
173: #endif
174:
175: #define gdt_desc_p(mycpu,sel) \
176: ((struct real_descriptor *)&curr_gdt(mycpu)[sel_idx(sel)])
177:
178: void
179: act_machine_switch_pcb( thread_act_t new_act )
180: {
181: pcb_t pcb = new_act->mact.pcb;
182: int mycpu;
183: {
184: register iopb_tss_t tss = pcb->ims.io_tss;
185: vm_offset_t pcb_stack_top;
186:
187: assert(new_act->thread != NULL);
188: assert(new_act->thread->kernel_stack != 0);
189: STACK_IEL(new_act->thread->kernel_stack)->saved_state =
190: &new_act->mact.pcb->iss;
191:
192: /*
193: * Save a pointer to the top of the "kernel" stack -
194: * actually the place in the PCB where a trap into
195: * kernel mode will push the registers.
196: * The location depends on V8086 mode. If we are
197: * not in V8086 mode, then a trap into the kernel
198: * won`t save the v86 segments, so we leave room.
199: */
200:
201: pcb_stack_top = (pcb->iss.efl & EFL_VM)
202: ? (int) (&pcb->iss + 1)
203: : (int) (&pcb->iss.v86_segs);
204:
205: mp_disable_preemption();
206: mycpu = cpu_number();
207:
208: if (tss == 0) {
209: /*
210: * No per-thread IO permissions.
211: * Use standard kernel TSS.
212: */
213: if (!(gdt_desc_p(mycpu,KERNEL_TSS)->access & ACC_TSS_BUSY))
214: set_tr(KERNEL_TSS);
215: curr_ktss(mycpu)->esp0 = pcb_stack_top;
216: }
217: else {
218: /*
219: * Set the IO permissions. Use this thread`s TSS.
220: */
221: *gdt_desc_p(mycpu,USER_TSS)
222: = *(struct real_descriptor *)tss->iopb_desc;
223: tss->tss.esp0 = pcb_stack_top;
224: set_tr(USER_TSS);
225: gdt_desc_p(mycpu,KERNEL_TSS)->access &= ~ ACC_TSS_BUSY;
226: }
227: }
228:
229: {
230: register user_ldt_t ldt = pcb->ims.ldt;
231: /*
232: * Set the thread`s LDT.
233: */
234: if (ldt == 0) {
235: /*
236: * Use system LDT.
237: */
238: set_ldt(KERNEL_LDT);
239: }
240: else {
241: /*
242: * Thread has its own LDT.
243: */
244: *gdt_desc_p(mycpu,USER_LDT) = ldt->desc;
245: set_ldt(USER_LDT);
246: }
247: }
248: mp_enable_preemption();
249: /*
250: * Load the floating-point context, if necessary.
251: */
252: fpu_load_context(pcb);
253:
254: }
255:
256: /*
257: * flush out any lazily evaluated HW state in the
258: * owning thread's context, before termination.
259: */
260: void
261: thread_machine_flush( thread_act_t cur_act )
262: {
263: fpflush(cur_act);
264: }
265:
266: /*
267: * Switch to the first thread on a CPU.
268: */
269: void
270: load_context(
271: thread_t new)
272: {
273: act_machine_switch_pcb(new->top_act);
274: Load_context(new);
275: }
276:
277: /*
278: * Number of times we needed to swap an activation back in before
279: * switching to it.
280: */
281: int switch_act_swapins = 0;
282:
283: /*
284: * machine_switch_act
285: *
286: * Machine-dependent details of activation switching. Called with
287: * RPC locks held and preemption disabled.
288: */
289: void
290: machine_switch_act(
291: thread_t thread,
292: thread_act_t old,
293: thread_act_t new,
294: int cpu)
295: {
296: /*
297: * Switch the vm, ast and pcb context.
298: * Save FP registers if in use and set TS (task switch) bit.
299: */
300: fpu_save_context(thread);
301:
302: active_stacks[cpu] = thread->kernel_stack;
303: ast_context(new, cpu);
304:
305: PMAP_SWITCH_CONTEXT(old, new, cpu);
306: act_machine_switch_pcb(new);
307: }
308:
309: /*
310: * Switch to a new thread.
311: * Save the old thread`s kernel state or continuation,
312: * and return it.
313: */
314: thread_t
315: switch_context(
316: thread_t old,
317: void (*continuation)(void),
318: thread_t new)
319: {
320: register thread_act_t old_act = old->top_act,
321: new_act = new->top_act;
322:
323: #if MACH_RT
324: assert(old_act->kernel_loaded ||
325: active_stacks[cpu_number()] == old_act->thread->kernel_stack);
326: assert (get_preemption_level() == 1);
327: #endif
328: check_simple_locks();
329:
330: /*
331: * Save FP registers if in use.
332: */
333: fpu_save_context(old);
334:
335: #if MACH_ASSERT
336: if (watchacts & WA_SWITCH)
337: printf("\tswitch_context(old=%x con=%x new=%x)\n",
338: old, continuation, new);
339: #endif /* MACH_ASSERT */
340:
341: /*
342: * Switch address maps if need be, even if not switching tasks.
343: * (A server activation may be "borrowing" a client map.)
344: */
345: {
346: int mycpu = cpu_number();
347:
348: PMAP_SWITCH_CONTEXT(old_act, new_act, mycpu)
349: }
350:
351: /*
352: * Load the rest of the user state for the new thread
353: */
354: act_machine_switch_pcb(new_act);
355: return(Switch_context(old, continuation, new));
356: }
357:
358: void
359: pcb_module_init(void)
360: {
361: fpu_module_init();
362: iopb_init();
363: }
364:
365: void
366: pcb_init( register thread_act_t thr_act )
367: {
368: register pcb_t pcb;
369:
370: assert(thr_act->mact.pcb == (pcb_t)0);
371: pcb = thr_act->mact.pcb = &thr_act->mact.xxx_pcb;
372:
373: #if MACH_ASSERT
374: if (watchacts & WA_PCB)
375: printf("pcb_init(%x) pcb=%x\n", thr_act, pcb);
376: #endif /* MACH_ASSERT */
377:
378: /*
379: * We can't let random values leak out to the user.
380: * (however, act_create() zeroed the entire thr_act, mact, pcb)
381: * bzero((char *) pcb, sizeof *pcb);
382: */
383: simple_lock_init(&pcb->lock, ETAP_MISC_PCB);
384:
385: /*
386: * Guarantee that the bootstrapped thread will be in user
387: * mode.
388: */
389: pcb->iss.cs = USER_CS;
390: pcb->iss.ss = USER_DS;
391: pcb->iss.ds = USER_DS;
392: pcb->iss.es = USER_DS;
393: pcb->iss.fs = USER_DS;
394: pcb->iss.gs = USER_DS;
395: pcb->iss.efl = EFL_USER_SET;
396: }
397:
398: /*
399: * Adjust saved register state for thread belonging to task
400: * created with kernel_task_create().
401: */
402: void
403: pcb_user_to_kernel(
404: thread_act_t thr_act)
405: {
406: register pcb_t pcb = thr_act->mact.pcb;
407:
408: pcb->iss.cs = KERNEL_CS;
409: pcb->iss.ss = KERNEL_DS;
410: pcb->iss.ds = KERNEL_DS;
411: pcb->iss.es = KERNEL_DS;
412: pcb->iss.fs = KERNEL_DS;
413: pcb->iss.gs = CPU_DATA;
414: }
415:
416: void
417: pcb_terminate(
418: register thread_act_t thr_act)
419: {
420: register pcb_t pcb = thr_act->mact.pcb;
421:
422: assert(pcb);
423:
424: if (pcb->ims.io_tss != 0)
425: iopb_destroy(pcb->ims.io_tss);
426: if (pcb->ims.ifps != 0)
427: fp_free(pcb->ims.ifps);
428: if (pcb->ims.ldt != 0)
429: user_ldt_free(pcb->ims.ldt);
430: thr_act->mact.pcb = (pcb_t)0;
431: }
432:
433: /*
434: * pcb_collect:
435: *
436: * Attempt to free excess pcb memory.
437: */
438:
439: void
440: pcb_collect(
441: register thread_act_t thr_act)
442: {
443: /* accomplishes very little */
444: }
445:
446: /*
447: * act_machine_sv_free
448: * release saveareas associated with an act. if flag is true, release
449: * user level savearea(s) too, else don't
450: */
451: void
452: act_machine_sv_free(thread_act_t act, int flag)
453: {
454:
455: }
456:
457: /*
458: * act_machine_set_state:
459: *
460: * Set the status of the specified thread. Called with "appropriate"
461: * thread-related locks held (see act_lock_thread()), so
462: * thr_act->thread is guaranteed not to change.
463: */
464:
465: kern_return_t
466: act_machine_set_state(
467: thread_act_t thr_act,
468: thread_flavor_t flavor,
469: thread_state_t tstate,
470: mach_msg_type_number_t count)
471: {
472: int kernel_act = thr_act->kernel_loading ||
473: thr_act->kernel_loaded;
474:
475: #if MACH_ASSERT
476: if (watchacts & WA_STATE)
477: printf("act_%x act_m_set_state(thr_act=%x,flav=%x,st=%x,cnt=%x)\n",
478: current_act(), thr_act, flavor, tstate, count);
479: #endif /* MACH_ASSERT */
480:
481: switch (flavor) {
482: case THREAD_SYSCALL_STATE:
483: {
484: register struct thread_syscall_state *state;
485: register struct i386_saved_state *saved_state = USER_REGS(thr_act);
486:
487: state = (struct thread_syscall_state *) tstate;
488: saved_state->eax = state->eax;
489: saved_state->edx = state->edx;
490: if (kernel_act)
491: saved_state->efl = state->efl;
492: else
493: saved_state->efl = (state->efl & ~EFL_USER_CLEAR) | EFL_USER_SET;
494: saved_state->eip = state->eip;
495: saved_state->uesp = state->esp;
496: break;
497: }
498:
499: case i386_SAVED_STATE:
500: {
501: register struct i386_saved_state *state;
502: register struct i386_saved_state *saved_state;
503:
504: if (count < i386_SAVED_STATE_COUNT) {
505: return(KERN_INVALID_ARGUMENT);
506: }
507:
508: state = (struct i386_saved_state *) tstate;
509:
510: saved_state = USER_REGS(thr_act);
511:
512: /*
513: * General registers
514: */
515: saved_state->edi = state->edi;
516: saved_state->esi = state->esi;
517: saved_state->ebp = state->ebp;
518: saved_state->uesp = state->uesp;
519: saved_state->ebx = state->ebx;
520: saved_state->edx = state->edx;
521: saved_state->ecx = state->ecx;
522: saved_state->eax = state->eax;
523: saved_state->eip = state->eip;
524: if (kernel_act)
525: saved_state->efl = state->efl;
526: else
527: saved_state->efl = (state->efl & ~EFL_USER_CLEAR)
528: | EFL_USER_SET;
529:
530: /*
531: * Segment registers. Set differently in V8086 mode.
532: */
533: if (state->efl & EFL_VM) {
534: /*
535: * Set V8086 mode segment registers.
536: */
537: saved_state->cs = state->cs & 0xffff;
538: saved_state->ss = state->ss & 0xffff;
539: saved_state->v86_segs.v86_ds = state->ds & 0xffff;
540: saved_state->v86_segs.v86_es = state->es & 0xffff;
541: saved_state->v86_segs.v86_fs = state->fs & 0xffff;
542: saved_state->v86_segs.v86_gs = state->gs & 0xffff;
543:
544: /*
545: * Zero protected mode segment registers.
546: */
547: saved_state->ds = 0;
548: saved_state->es = 0;
549: saved_state->fs = 0;
550: saved_state->gs = 0;
551:
552: if (thr_act->mact.pcb->ims.v86s.int_table) {
553: /*
554: * Hardware assist on.
555: */
556: thr_act->mact.pcb->ims.v86s.flags =
557: state->efl & (EFL_TF | EFL_IF);
558: }
559: }
560: else if (!kernel_act) {
561: /*
562: * 386 mode. Set segment registers for flat
563: * 32-bit address space.
564: */
565: saved_state->cs = USER_CS;
566: saved_state->ss = USER_DS;
567: saved_state->ds = USER_DS;
568: saved_state->es = USER_DS;
569: saved_state->fs = USER_DS;
570: saved_state->gs = USER_DS;
571: }
572: else {
573: /*
574: * User setting segment registers.
575: * Code and stack selectors have already been
576: * checked. Others will be reset by 'iret'
577: * if they are not valid.
578: */
579: saved_state->cs = state->cs;
580: saved_state->ss = state->ss;
581: saved_state->ds = state->ds;
582: saved_state->es = state->es;
583: saved_state->fs = state->fs;
584: saved_state->gs = state->gs;
585: }
586: break;
587: }
588:
589: case i386_NEW_THREAD_STATE:
590: case i386_REGS_SEGS_STATE:
591: {
592: register struct i386_new_thread_state *state;
593: register struct i386_saved_state *saved_state;
594:
595: if (count < i386_NEW_THREAD_STATE_COUNT) {
596: return(KERN_INVALID_ARGUMENT);
597: }
598:
599: if (flavor == i386_REGS_SEGS_STATE) {
600: /*
601: * Code and stack selectors must not be null,
602: * and must have user protection levels.
603: * Only the low 16 bits are valid.
604: */
605: state->cs &= 0xffff;
606: state->ss &= 0xffff;
607: state->ds &= 0xffff;
608: state->es &= 0xffff;
609: state->fs &= 0xffff;
610: state->gs &= 0xffff;
611:
612: if (!kernel_act &&
613: (state->cs == 0 || (state->cs & SEL_PL) != SEL_PL_U
614: || state->ss == 0 || (state->ss & SEL_PL) != SEL_PL_U))
615: return KERN_INVALID_ARGUMENT;
616: }
617:
618: state = (struct i386_new_thread_state *) tstate;
619:
620: saved_state = USER_REGS(thr_act);
621:
622: /*
623: * General registers
624: */
625: saved_state->edi = state->edi;
626: saved_state->esi = state->esi;
627: saved_state->ebp = state->ebp;
628: saved_state->uesp = state->uesp;
629: saved_state->ebx = state->ebx;
630: saved_state->edx = state->edx;
631: saved_state->ecx = state->ecx;
632: saved_state->eax = state->eax;
633: saved_state->eip = state->eip;
634: if (kernel_act)
635: saved_state->efl = state->efl;
636: else
637: saved_state->efl = (state->efl & ~EFL_USER_CLEAR)
638: | EFL_USER_SET;
639:
640: /*
641: * Segment registers. Set differently in V8086 mode.
642: */
643: if (state->efl & EFL_VM) {
644: /*
645: * Set V8086 mode segment registers.
646: */
647: saved_state->cs = state->cs & 0xffff;
648: saved_state->ss = state->ss & 0xffff;
649: saved_state->v86_segs.v86_ds = state->ds & 0xffff;
650: saved_state->v86_segs.v86_es = state->es & 0xffff;
651: saved_state->v86_segs.v86_fs = state->fs & 0xffff;
652: saved_state->v86_segs.v86_gs = state->gs & 0xffff;
653:
654: /*
655: * Zero protected mode segment registers.
656: */
657: saved_state->ds = 0;
658: saved_state->es = 0;
659: saved_state->fs = 0;
660: saved_state->gs = 0;
661:
662: if (thr_act->mact.pcb->ims.v86s.int_table) {
663: /*
664: * Hardware assist on.
665: */
666: thr_act->mact.pcb->ims.v86s.flags =
667: state->efl & (EFL_TF | EFL_IF);
668: }
669: }
670: else if (flavor == i386_NEW_THREAD_STATE && !kernel_act) {
671: /*
672: * 386 mode. Set segment registers for flat
673: * 32-bit address space.
674: */
675: saved_state->cs = USER_CS;
676: saved_state->ss = USER_DS;
677: saved_state->ds = USER_DS;
678: saved_state->es = USER_DS;
679: saved_state->fs = USER_DS;
680: saved_state->gs = USER_DS;
681: }
682: else {
683: /*
684: * User setting segment registers.
685: * Code and stack selectors have already been
686: * checked. Others will be reset by 'iret'
687: * if they are not valid.
688: */
689: saved_state->cs = state->cs;
690: saved_state->ss = state->ss;
691: saved_state->ds = state->ds;
692: saved_state->es = state->es;
693: saved_state->fs = state->fs;
694: saved_state->gs = state->gs;
695: }
696: break;
697: }
698:
699: case i386_FLOAT_STATE: {
700:
701: if (count < i386_FLOAT_STATE_COUNT)
702: return(KERN_INVALID_ARGUMENT);
703:
704: return fpu_set_state(thr_act,(struct i386_float_state*)tstate);
705: }
706:
707: /*
708: * Temporary - replace by i386_io_map
709: */
710: case i386_ISA_PORT_MAP_STATE: {
711: register struct i386_isa_port_map_state *state;
712: register iopb_tss_t tss;
713:
714: if (count < i386_ISA_PORT_MAP_STATE_COUNT)
715: return(KERN_INVALID_ARGUMENT);
716:
717: break;
718: }
719:
720: case i386_V86_ASSIST_STATE:
721: {
722: register struct i386_v86_assist_state *state;
723: vm_offset_t int_table;
724: int int_count;
725:
726: if (count < i386_V86_ASSIST_STATE_COUNT)
727: return KERN_INVALID_ARGUMENT;
728:
729: state = (struct i386_v86_assist_state *) tstate;
730: int_table = state->int_table;
731: int_count = state->int_count;
732:
733: if (int_table >= VM_MAX_ADDRESS ||
734: int_table +
735: int_count * sizeof(struct v86_interrupt_table)
736: > VM_MAX_ADDRESS)
737: return KERN_INVALID_ARGUMENT;
738:
739: thr_act->mact.pcb->ims.v86s.int_table = int_table;
740: thr_act->mact.pcb->ims.v86s.int_count = int_count;
741:
742: thr_act->mact.pcb->ims.v86s.flags =
743: USER_REGS(thr_act)->efl & (EFL_TF | EFL_IF);
744: break;
745: }
746:
747: case i386_THREAD_STATE: {
748: struct i386_saved_state *saved_state;
749: i386_thread_state_t *state25;
750:
751: saved_state = USER_REGS(thr_act);
752: state25 = (i386_thread_state_t *)tstate;
753:
754: saved_state->eax = state25->eax;
755: saved_state->ebx = state25->ebx;
756: saved_state->ecx = state25->ecx;
757: saved_state->edx = state25->edx;
758: saved_state->edi = state25->edi;
759: saved_state->esi = state25->esi;
760: saved_state->ebp = state25->ebp;
761: saved_state->uesp = state25->esp;
762: saved_state->efl = (state25->eflags & ~EFL_USER_CLEAR)
763: | EFL_USER_SET;
764: saved_state->eip = state25->eip;
765: saved_state->cs = USER_CS; /* FIXME? */
766: saved_state->ss = USER_DS;
767: saved_state->ds = USER_DS;
768: saved_state->es = USER_DS;
769: saved_state->fs = USER_DS;
770: saved_state->gs = USER_DS;
771: }
772: break;
773:
774: default:
775: return(KERN_INVALID_ARGUMENT);
776: }
777:
778: return(KERN_SUCCESS);
779: }
780:
781: /*
782: * thread_getstatus:
783: *
784: * Get the status of the specified thread.
785: */
786:
787:
788: kern_return_t
789: act_machine_get_state(
790: thread_act_t thr_act,
791: thread_flavor_t flavor,
792: thread_state_t tstate,
793: mach_msg_type_number_t *count)
794: {
795: #if MACH_ASSERT
796: if (watchacts & WA_STATE)
797: printf("act_%x act_m_get_state(thr_act=%x,flav=%x,st=%x,cnt@%x=%x)\n",
798: current_act(), thr_act, flavor, tstate,
799: count, (count ? *count : 0));
800: #endif /* MACH_ASSERT */
801:
802: switch (flavor) {
803:
804: case i386_SAVED_STATE:
805: {
806: register struct i386_saved_state *state;
807: register struct i386_saved_state *saved_state;
808:
809: if (*count < i386_SAVED_STATE_COUNT)
810: return(KERN_INVALID_ARGUMENT);
811:
812: state = (struct i386_saved_state *) tstate;
813: saved_state = USER_REGS(thr_act);
814:
815: /*
816: * First, copy everything:
817: */
818: *state = *saved_state;
819:
820: if (saved_state->efl & EFL_VM) {
821: /*
822: * V8086 mode.
823: */
824: state->ds = saved_state->v86_segs.v86_ds & 0xffff;
825: state->es = saved_state->v86_segs.v86_es & 0xffff;
826: state->fs = saved_state->v86_segs.v86_fs & 0xffff;
827: state->gs = saved_state->v86_segs.v86_gs & 0xffff;
828:
829: if (thr_act->mact.pcb->ims.v86s.int_table) {
830: /*
831: * Hardware assist on
832: */
833: if ((thr_act->mact.pcb->ims.v86s.flags &
834: (EFL_IF|V86_IF_PENDING)) == 0)
835: state->efl &= ~EFL_IF;
836: }
837: }
838: else {
839: /*
840: * 386 mode.
841: */
842: state->ds = saved_state->ds & 0xffff;
843: state->es = saved_state->es & 0xffff;
844: state->fs = saved_state->fs & 0xffff;
845: state->gs = saved_state->gs & 0xffff;
846: }
847: *count = i386_SAVED_STATE_COUNT;
848: break;
849: }
850:
851: case i386_NEW_THREAD_STATE:
852: case i386_REGS_SEGS_STATE:
853: {
854: register struct i386_new_thread_state *state;
855: register struct i386_saved_state *saved_state;
856:
857: if (*count < i386_NEW_THREAD_STATE_COUNT)
858: return(KERN_INVALID_ARGUMENT);
859:
860: state = (struct i386_new_thread_state *) tstate;
861: saved_state = USER_REGS(thr_act);
862:
863: /*
864: * General registers.
865: */
866: state->edi = saved_state->edi;
867: state->esi = saved_state->esi;
868: state->ebp = saved_state->ebp;
869: state->ebx = saved_state->ebx;
870: state->edx = saved_state->edx;
871: state->ecx = saved_state->ecx;
872: state->eax = saved_state->eax;
873: state->eip = saved_state->eip;
874: state->efl = saved_state->efl;
875: state->uesp = saved_state->uesp;
876:
877: state->cs = saved_state->cs;
878: state->ss = saved_state->ss;
879: if (saved_state->efl & EFL_VM) {
880: /*
881: * V8086 mode.
882: */
883: state->ds = saved_state->v86_segs.v86_ds & 0xffff;
884: state->es = saved_state->v86_segs.v86_es & 0xffff;
885: state->fs = saved_state->v86_segs.v86_fs & 0xffff;
886: state->gs = saved_state->v86_segs.v86_gs & 0xffff;
887:
888: if (thr_act->mact.pcb->ims.v86s.int_table) {
889: /*
890: * Hardware assist on
891: */
892: if ((thr_act->mact.pcb->ims.v86s.flags &
893: (EFL_IF|V86_IF_PENDING)) == 0)
894: state->efl &= ~EFL_IF;
895: }
896: }
897: else {
898: /*
899: * 386 mode.
900: */
901: state->ds = saved_state->ds & 0xffff;
902: state->es = saved_state->es & 0xffff;
903: state->fs = saved_state->fs & 0xffff;
904: state->gs = saved_state->gs & 0xffff;
905: }
906: *count = i386_NEW_THREAD_STATE_COUNT;
907: break;
908: }
909:
910: case THREAD_SYSCALL_STATE:
911: {
912: register struct thread_syscall_state *state;
913: register struct i386_saved_state *saved_state = USER_REGS(thr_act);
914:
915: state = (struct thread_syscall_state *) tstate;
916: state->eax = saved_state->eax;
917: state->edx = saved_state->edx;
918: state->efl = saved_state->efl;
919: state->eip = saved_state->eip;
920: state->esp = saved_state->uesp;
921: *count = i386_THREAD_SYSCALL_STATE_COUNT;
922: break;
923: }
924:
925: case THREAD_STATE_FLAVOR_LIST:
926: if (*count < 5)
927: return (KERN_INVALID_ARGUMENT);
928: tstate[0] = i386_NEW_THREAD_STATE;
929: tstate[1] = i386_FLOAT_STATE;
930: tstate[2] = i386_ISA_PORT_MAP_STATE;
931: tstate[3] = i386_V86_ASSIST_STATE;
932: tstate[4] = THREAD_SYSCALL_STATE;
933: *count = 5;
934: break;
935:
936: case i386_FLOAT_STATE: {
937:
938: if (*count < i386_FLOAT_STATE_COUNT)
939: return(KERN_INVALID_ARGUMENT);
940:
941: *count = i386_FLOAT_STATE_COUNT;
942: return fpu_get_state(thr_act,(struct i386_float_state *)tstate);
943: }
944:
945: /*
946: * Temporary - replace by i386_io_map
947: */
948: case i386_ISA_PORT_MAP_STATE: {
949: register struct i386_isa_port_map_state *state;
950: register iopb_tss_t tss;
951:
952: if (*count < i386_ISA_PORT_MAP_STATE_COUNT)
953: return(KERN_INVALID_ARGUMENT);
954:
955: state = (struct i386_isa_port_map_state *) tstate;
956: tss = thr_act->mact.pcb->ims.io_tss;
957:
958: if (tss == 0) {
959: int i;
960:
961: /*
962: * The thread has no ktss, so no IO permissions.
963: */
964:
965: for (i = 0; i < sizeof state->pm; i++)
966: state->pm[i] = 0xff;
967: } else {
968: /*
969: * The thread has its own ktss.
970: */
971:
972: bcopy((char *) tss->bitmap,
973: (char *) state->pm,
974: sizeof state->pm);
975: }
976:
977: *count = i386_ISA_PORT_MAP_STATE_COUNT;
978: break;
979: }
980:
981: case i386_V86_ASSIST_STATE:
982: {
983: register struct i386_v86_assist_state *state;
984:
985: if (*count < i386_V86_ASSIST_STATE_COUNT)
986: return KERN_INVALID_ARGUMENT;
987:
988: state = (struct i386_v86_assist_state *) tstate;
989: state->int_table = thr_act->mact.pcb->ims.v86s.int_table;
990: state->int_count = thr_act->mact.pcb->ims.v86s.int_count;
991:
992: *count = i386_V86_ASSIST_STATE_COUNT;
993: break;
994: }
995:
996: case i386_THREAD_STATE: {
997: struct i386_saved_state *saved_state;
998: i386_thread_state_t *state;
999:
1000: saved_state = USER_REGS(thr_act);
1001: state = (i386_thread_state_t *)tstate;
1002:
1003: state->eax = saved_state->eax;
1004: state->ebx = saved_state->ebx;
1005: state->ecx = saved_state->ecx;
1006: state->edx = saved_state->edx;
1007: state->edi = saved_state->edi;
1008: state->esi = saved_state->esi;
1009: state->ebp = saved_state->ebp;
1010: state->esp = saved_state->uesp;
1011: state->eflags = saved_state->efl;
1012: state->eip = saved_state->eip;
1013: state->cs = saved_state->cs;
1014: state->ss = saved_state->ss;
1015: state->ds = saved_state->ds;
1016: state->es = saved_state->es;
1017: state->fs = saved_state->fs;
1018: state->gs = saved_state->gs;
1019: break;
1020: }
1021:
1022: default:
1023: return(KERN_INVALID_ARGUMENT);
1024: }
1025:
1026: return(KERN_SUCCESS);
1027: }
1028:
1029: /*
1030: * Alter the thread`s state so that a following thread_exception_return
1031: * will make the thread return 'retval' from a syscall.
1032: */
1033: void
1034: thread_set_syscall_return(
1035: thread_t thread,
1036: kern_return_t retval)
1037: {
1038: thread->top_act->mact.pcb->iss.eax = retval;
1039: }
1040:
1041: /*
1042: * Initialize the machine-dependent state for a new thread.
1043: */
1044: kern_return_t
1045: thread_machine_create(thread_t thread, thread_act_t thr_act, void (*start_pos)(void))
1046: {
1047: MachineThrAct_t mact = &thr_act->mact;
1048:
1049: #if MACH_ASSERT
1050: if (watchacts & WA_PCB)
1051: printf("thread_machine_create(thr=%x,thr_act=%x,st=%x)\n",
1052: thread, thr_act, start_pos);
1053: #endif /* MACH_ASSERT */
1054:
1055: assert(thread != NULL);
1056: assert(thr_act != NULL);
1057:
1058: /*
1059: * Allocate a kernel stack per shuttle
1060: */
1061: thread->kernel_stack = (int)stack_alloc(thread,start_pos);
1062: assert(thread->kernel_stack != 0);
1063:
1064: /*
1065: * Point top of kernel stack to user`s registers.
1066: */
1067: STACK_IEL(thread->kernel_stack)->saved_state = &mact->pcb->iss;
1068:
1069: /*
1070: * Utah code fiddles with pcb here - (we don't need to)
1071: */
1072: return(KERN_SUCCESS);
1073: }
1074:
1075: /*
1076: * Machine-dependent cleanup prior to destroying a thread
1077: */
1078: void
1079: thread_machine_destroy( thread_t thread )
1080: {
1081: spl_t s;
1082:
1083: assert(thread->kernel_stack != 0);
1084:
1085: s = splsched();
1086: stack_free(thread);
1087: splx(s);
1088: }
1089:
1090: /*
1091: * This is used to set the current thr_act/thread
1092: * when starting up a new processor
1093: */
1094: void
1095: thread_machine_set_current( thread_t thread )
1096: {
1097: register int my_cpu;
1098:
1099: mp_disable_preemption();
1100: my_cpu = cpu_number();
1101:
1102: cpu_data[my_cpu].active_thread = thread;
1103: active_kloaded[my_cpu] =
1104: thread->top_act->kernel_loaded ? thread->top_act : THR_ACT_NULL;
1105:
1106: mp_enable_preemption();
1107: }
1108:
1109:
1110: /*
1111: * Pool of kernel activations.
1112: */
1113:
1114: void act_machine_init()
1115: {
1116: int i;
1117: thread_act_t thr_act;
1118:
1119: #if MACH_ASSERT
1120: if (watchacts & WA_PCB)
1121: printf("act_machine_init()\n");
1122: #endif /* MACH_ASSERT */
1123:
1124: /* Good to verify this once */
1125: assert( THREAD_MACHINE_STATE_MAX <= THREAD_STATE_MAX );
1126:
1127: /*
1128: * If we start using kernel activations,
1129: * would normally create kernel_thread_pool here,
1130: * populating it from the act_zone
1131: */
1132: }
1133:
1134: kern_return_t
1135: act_machine_create(task_t task, thread_act_t thr_act)
1136: {
1137: MachineThrAct_t mact = &thr_act->mact;
1138: pcb_t pcb;
1139:
1140: #if MACH_ASSERT
1141: if (watchacts & WA_PCB)
1142: printf("act_machine_create(task=%x,thr_act=%x) pcb=%x\n",
1143: task,thr_act, &mact->xxx_pcb);
1144: #endif /* MACH_ASSERT */
1145:
1146: /*
1147: * Clear & Init the pcb (sets up user-mode s regs)
1148: */
1149: pcb_init(thr_act);
1150:
1151: return KERN_SUCCESS;
1152: }
1153:
1154: void
1155: act_machine_destroy(thread_act_t thr_act)
1156: {
1157:
1158: #if MACH_ASSERT
1159: if (watchacts & WA_PCB)
1160: printf("act_machine_destroy(0x%x)\n", thr_act);
1161: #endif /* MACH_ASSERT */
1162:
1163: pcb_terminate(thr_act);
1164: }
1165:
1166: void
1167: act_machine_return(int code)
1168: {
1169: thread_act_t thr_act = current_act();
1170: thread_act_t cur_act;
1171: thread_t cur_thread = current_thread();
1172: vm_offset_t pcb_stack;
1173: unsigned int uesp, ueip;
1174: struct ipc_port *iplock;
1175:
1176: #if MACH_ASSERT
1177: /*
1178: * We don't go through the locking dance here needed to
1179: * acquire thr_act->thread safely.
1180: */
1181:
1182: if (watchacts & WA_EXIT)
1183: printf("act_machine_return(0x%x) cur_act=%x(%d) thr=%x(%d)\n",
1184: code, thr_act, thr_act->ref_count,
1185: thr_act->thread, thr_act->thread
1186: ? thr_act->thread->ref_count : 0);
1187: #endif /* MACH_ASSERT */
1188:
1189: /*
1190: * This code is called with nothing locked.
1191: * It also returns with nothing locked, if it returns.
1192: *
1193: * This routine terminates the current thread activation.
1194: * If this is the only activation associated with its
1195: * thread shuttle, then the entire thread (shuttle plus
1196: * activation) is terminated.
1197: */
1198: assert( code == KERN_TERMINATED );
1199: assert( thr_act );
1200:
1201: #ifdef CALLOUT_RPC_MODEL
1202:
1203: /*
1204: * JMM - RPC is not going to be done with a callout/direct-
1205: * stack manipulation mechanism. Instead we will return/
1206: * unwind normally as if from a continuation.
1207: */
1208: act_lock_thread(thr_act);
1209: iplock = thr_act->pool_port; /* remember for unlock call */
1210:
1211: if (thr_act->thread->top_act != thr_act) {
1212: /*
1213: * this is not the top activation;
1214: * if possible, we should clone the shuttle so that
1215: * both the root RPC-chain and the soon-to-be-orphaned
1216: * RPC-chain have shuttles
1217: *
1218: * JMM - Cloning shuttles isn't the right approach. We
1219: * need to alert the higher up activations to return our
1220: * shuttle (because scheduling attributes may TRUELY be
1221: * unique and not cloneable.
1222: */
1223: act_unlock_thread(thr_act);
1224: panic("act_machine_return: ORPHAN CASE NOT YET IMPLEMENTED");
1225: }
1226:
1227: if (thr_act->lower != THR_ACT_NULL) {
1228: /* send it an appropriate return code */
1229: thr_act->lower->alerts |= SERVER_TERMINATED;
1230: install_special_handler(thr_act->lower);
1231:
1232: /* Return to previous act with error code */
1233: act_locked_act_reference(thr_act); /* keep it around */
1234: act_switch_swapcheck(cur_thread, (ipc_port_t)0);
1235: (void) switch_act(THR_ACT_NULL);
1236: /* assert(thr_act->ref_count == 0); */ /* XXX */
1237: cur_act = cur_thread->top_act;
1238: MACH_RPC_RET(cur_act) = KERN_RPC_SERVER_TERMINATED;
1239:
1240: machine_kernel_stack_init(cur_thread,
1241: (void (*)(void)) mach_rpc_return_error);
1242: /*
1243: * The following unlocks must be done separately since fields
1244: * used by `act_unlock_thread()' have been cleared, meaning
1245: * that it would not release all of the appropriate locks.
1246: */
1247: rpc_unlock(cur_thread);
1248: if (iplock) ip_unlock(iplock); /* must be done separately */
1249: act_unlock(thr_act);
1250: act_deallocate(thr_act); /* free it */
1251: Load_context(cur_thread);
1252: /*NOTREACHED*/
1253:
1254: panic("act_machine_return: TALKING ZOMBIE! (2)");
1255: }
1256: act_unlock_thread(thr_act);
1257:
1258: #endif /* CALLOUT_RPC_MODEL */
1259:
1260: /* This is the only activation attached to the shuttle... */
1261: /* terminate the entire thread (shuttle plus activation) */
1262:
1263: assert(thr_act->thread->top_act == thr_act);
1264: thread_terminate_self();
1265:
1266: /*NOTREACHED*/
1267:
1268: panic("act_machine_return: TALKING ZOMBIE! (1)");
1269: }
1270:
1271:
1272: /*
1273: * Perform machine-dependent per-thread initializations
1274: */
1275: void
1276: thread_machine_init(void)
1277: {
1278: pcb_module_init();
1279: }
1280:
1281: /*
1282: * Some routines for debugging activation code
1283: */
1284: static void dump_handlers(thread_act_t);
1285: void dump_regs(thread_act_t);
1286:
1287: static void
1288: dump_handlers(thread_act_t thr_act)
1289: {
1290: ReturnHandler *rhp = thr_act->handlers;
1291: int counter = 0;
1292:
1293: printf("\t");
1294: while (rhp) {
1295: if (rhp == &thr_act->special_handler){
1296: if (rhp->next)
1297: printf("[NON-Zero next ptr(%x)]", rhp->next);
1298: printf("special_handler()->");
1299: break;
1300: }
1301: printf("hdlr_%d(%x)->",counter,rhp->handler);
1302: rhp = rhp->next;
1303: if (++counter > 32) {
1304: printf("Aborting: HUGE handler chain\n");
1305: break;
1306: }
1307: }
1308: printf("HLDR_NULL\n");
1309: }
1310:
1311: void
1312: dump_regs(thread_act_t thr_act)
1313: {
1314: if (thr_act->mact.pcb) {
1315: register struct i386_saved_state *ssp = USER_REGS(thr_act);
1316: /* Print out user register state */
1317: printf("\tRegs:\tedi=%x esi=%x ebp=%x ebx=%x edx=%x\n",
1318: ssp->edi, ssp->esi, ssp->ebp, ssp->ebx, ssp->edx);
1319: printf("\t\tecx=%x eax=%x eip=%x efl=%x uesp=%x\n",
1320: ssp->ecx, ssp->eax, ssp->eip, ssp->efl, ssp->uesp);
1321: printf("\t\tcs=%x ss=%x\n", ssp->cs, ssp->ss);
1322: }
1323: }
1324:
1325: int
1326: dump_act(thread_act_t thr_act)
1327: {
1328: if (!thr_act)
1329: return(0);
1330:
1331: printf("thr_act(0x%x)(%d): thread=%x(%d) task=%x(%d)\n",
1332: thr_act, thr_act->ref_count,
1333: thr_act->thread, thr_act->thread ? thr_act->thread->ref_count:0,
1334: thr_act->task, thr_act->task ? thr_act->task->ref_count : 0);
1335:
1336: if (thr_act->pool_port) {
1337: thread_pool_t actpp = &thr_act->pool_port->ip_thread_pool;
1338: printf("\tpool(acts_p=%x, waiting=%d) pool_next %x\n",
1339: actpp->thr_acts, actpp->waiting, thr_act->thread_pool_next);
1340: }else
1341: printf("\tno thread_pool\n");
1342:
1343: printf("\talerts=%x mask=%x susp=%d user_stop=%d active=%x ast=%x\n",
1344: thr_act->alerts, thr_act->alert_mask,
1345: thr_act->suspend_count, thr_act->user_stop_count,
1346: thr_act->active, thr_act->ast);
1347: printf("\thi=%x lo=%x\n", thr_act->higher, thr_act->lower);
1348: printf("\tpcb=%x, ustk=%x\n",
1349: thr_act->mact.pcb, thr_act->user_stack);
1350:
1351: if (thr_act->thread && thr_act->thread->kernel_stack) {
1352: vm_offset_t stack = thr_act->thread->kernel_stack;
1353:
1354: printf("\tk_stk %x eip %x ebx %x esp %x iss %x\n",
1355: stack, STACK_IKS(stack)->k_eip, STACK_IKS(stack)->k_ebx,
1356: STACK_IKS(stack)->k_esp, STACK_IEL(stack)->saved_state);
1357: }
1358:
1359: dump_handlers(thr_act);
1360: dump_regs(thr_act);
1361: return((int)thr_act);
1362: }
1363: unsigned int
1364: get_useraddr()
1365: {
1366:
1367: thread_act_t thr_act = current_act();
1368:
1369: if (thr_act->mact.pcb)
1370: return(thr_act->mact.pcb->iss.eip);
1371: else
1372: return(0);
1373:
1374: }
1375:
1376: void
1377: thread_swapin_mach_alloc(thread_t thread)
1378: {
1379:
1380: /* 386 does not have saveareas */
1381:
1382: }
1383: /*
1384: * detach and return a kernel stack from a thread
1385: */
1386:
1387: vm_offset_t
1388: stack_detach(thread_t thread)
1389: {
1390: vm_offset_t stack;
1391:
1392: #ifdef KDEBUG
1393: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_STACK_DETACH),
1394: thread, thread->priority,
1395: thread->sched_pri, 0,
1396: 0);
1397: #endif
1398:
1399: stack = thread->kernel_stack;
1400: thread->kernel_stack = 0;
1401: return(stack);
1402: }
1403:
1404: /*
1405: * attach a kernel stack to a thread and initialize it
1406: */
1407:
1408: void
1409: stack_attach(struct thread_shuttle *thread,
1410: vm_offset_t stack,
1411: void (*continuation)(void))
1412: {
1413: struct i386_kernel_state *statep;
1414: thread_act_t thr_act;
1415:
1416: #ifdef KDEBUG
1417: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_STACK_ATTACH),
1418: thread, thread->priority,
1419: thread->sched_pri, continuation,
1420: 0);
1421: #endif
1422:
1423: assert(stack);
1424: statep = STACK_IKS(stack);
1425: thread->kernel_stack = stack;
1426:
1427: statep->k_eip = (unsigned long) Thread_continue;
1428: statep->k_ebx = (unsigned long) continuation;
1429: statep->k_esp = (unsigned long) STACK_IEL(stack);
1430:
1431: STACK_IEL(stack)->saved_state = &thr_act->mact.pcb->iss;
1432:
1433: return;
1434: }
1435:
1436: /*
1437: * move a stack from old to new thread
1438: */
1439:
1440: void
1441: stack_handoff(thread_t old,
1442: thread_t new)
1443: {
1444:
1445: vm_offset_t stack;
1446: pmap_t new_pmap;
1447:
1448: #ifdef KDEBUG
1449: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_STACK_HANDOFF),
1450: thread, thread->priority,
1451: thread->sched_pri, continuation,
1452: 0);
1453: #endif
1454:
1455: assert(new->top_act);
1456: assert(old->top_act);
1457:
1458: stack = stack_detach(old);
1459: stack_attach(new, stack, 0);
1460:
1461: new_pmap = new->top_act->task->map->pmap;
1462: if (old->top_act->task->map->pmap != new_pmap)
1463: PMAP_ACTIVATE_MAP(new->top_act->task->map, cpu_number());
1464:
1465: thread_machine_set_current(new);
1466:
1467: active_stacks[cpu_number()] = new->kernel_stack;
1468:
1469: return;
1470: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.