![[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 Darwin 0.x] / kernel / machdep / i386|
Return to pcb.c CVS log | Up to [Apple Darwin 0.x] / kernel / machdep / i386 |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright (c) 1992 NeXT Computer, Inc.
27: *
28: * Intel386 Family: Machine dependent thread module.
29: *
30: * HISTORY
31: *
32: * 6 April 1992 ? at NeXT
33: * Created.
34: */
35:
36: #import <mach/mach_types.h>
37:
38: #import <kern/mach_param.h>
39:
40: #import <architecture/i386/table.h>
41:
42: #import <machdep/i386/fp_exported.h>
43: #import <machdep/i386/configure.h>
44:
45: #import <machdep/i386/ldt.h>
46: #import <machdep/i386/table_inline.h>
47: #import <machdep/i386/desc_inline.h>
48: #import <machdep/i386/sel_inline.h>
49: #import <machdep/i386/cpu_inline.h>
50:
51: /* U**X crap!! */
52: #import <sys/param.h>
53: #import <sys/proc.h>
54:
55: #import <fp_emul.h>
56: #import <pc_support.h>
57:
58: zone_t pcb_zone;
59:
60: vm_offset_t stack_pointers[NCPUS];
61: boolean_t empty_stacks[NCPUS];
62:
63: /*
64: * The base of the kernel stack
65: * is different when a thread is
66: * in v86 mode.
67: */
68: #define KERNEL_STACK_BASE(state) \
69: ((unsigned int) &(state)->frame.v_es)
70:
71: #define KERNEL_V86_STACK_BASE(state) \
72: ((unsigned int) &(&(state)->frame)[1])
73:
74: void
75: stack_attach(
76: thread_t thread,
77: vm_offset_t stack,
78: void (*continuation)(void)
79: )
80: {
81: tss_t *tss;
82: extern void _stack_attach(void);
83:
84: thread->kernel_stack = stack;
85:
86: tss = thread->pcb->tss;
87: tss->esp = tss->ebp = stack + KERNEL_STACK_SIZE;
88: tss->eip = (unsigned int)_stack_attach;
89: tss->ebx = (unsigned int)continuation;
90: }
91:
92:
93: vm_offset_t
94: stack_detach(
95: thread_t thread
96: )
97: {
98: vm_offset_t stack;
99:
100: stack = thread->kernel_stack;
101: thread->kernel_stack = 0;
102:
103: return (stack);
104: }
105:
106: void
107: stack_handoff(
108: thread_t old,
109: thread_t new
110: )
111: {
112: struct pcb *new_pcb = new->pcb,
113: *old_pcb = old->pcb;
114: vm_offset_t stack = stack_detach(old);
115:
116: stack_attach(new, stack, 0);
117:
118: /*
119: * Change software state.
120: */
121: if (new->task != old->task) {
122: int mycpu = cpu_number();
123:
124: PMAP_DEACTIVATE(vm_map_pmap(old->task->map), old, mycpu);
125: PMAP_ACTIVATE(vm_map_pmap(new->task->map), new, mycpu);
126: }
127:
128: current_thread() = new;
129:
130: /*
131: * Change hardware state.
132: */
133: if (new_pcb->tss->cr3 != old_pcb->tss->cr3)
134: set_cr3(new_pcb->tss->cr3);
135:
136: if (new_pcb->ldt != old_pcb->ldt
137: || new_pcb->ldt_size != old_pcb->ldt_size) {
138: map_ldt(sel_to_gdt_entry(LDT_SEL),
139: (vm_offset_t) new_pcb->ldt,
140: (vm_size_t) new_pcb->ldt_size);
141: lldt();
142: }
143:
144: map_tss(sel_to_gdt_entry(TSS_SEL),
145: (vm_offset_t) new_pcb->tss
146: + KERNEL_LINEAR_BASE,
147: (vm_size_t) new_pcb->tss_size);
148: ltr(); setts();
149: }
150:
151: extern
152: thread_t
153: _switch_tss(
154: tss_t *old_tss,
155: tss_t *new_tss,
156: thread_t old
157: );
158:
159: thread_t
160: switch_context(
161: thread_t old,
162: void (*continuation)(void),
163: thread_t new
164: )
165: {
166: struct pcb *new_pcb = new->pcb,
167: *old_pcb = old->pcb;
168:
169: /*
170: * Change software state.
171: */
172: if (new->task != old->task) {
173: int mycpu = cpu_number();
174:
175: PMAP_DEACTIVATE(vm_map_pmap(old->task->map), old, mycpu);
176: PMAP_ACTIVATE(vm_map_pmap(new->task->map), new, mycpu);
177: }
178:
179: current_thread() = new;
180: current_stack() = new->kernel_stack;
181: current_stack_pointer() = new->kernel_stack + KERNEL_STACK_SIZE;
182:
183: /*
184: * Change hardware state.
185: */
186: if (new_pcb->tss->cr3 != old_pcb->tss->cr3)
187: set_cr3(new_pcb->tss->cr3);
188:
189: if (new_pcb->ldt != old_pcb->ldt
190: || new_pcb->ldt_size != old_pcb->ldt_size) {
191: map_ldt(sel_to_gdt_entry(LDT_SEL),
192: (vm_offset_t) new_pcb->ldt,
193: (vm_size_t) new_pcb->ldt_size);
194: lldt();
195: }
196:
197: map_tss(sel_to_gdt_entry(TSS_SEL),
198: (vm_offset_t) new_pcb->tss
199: + KERNEL_LINEAR_BASE,
200: (vm_size_t) new_pcb->tss_size);
201: ltr(); setts();
202:
203: if (old->swap_func = continuation)
204: return _switch_tss(0, new_pcb->tss, old);
205: else
206: return _switch_tss(old_pcb->tss, new_pcb->tss, old);
207: }
208:
209: void
210: call_continuation(
211: void (*continuation)(void)
212: )
213: {
214: _call_with_stack(continuation, current_stack_pointer());
215: /* NOTREACHED */
216: }
217:
218: void
219: pcb_module_init(void)
220: {
221: pcb_zone = zinit(
222: sizeof (struct pcb),
223: THREAD_MAX * sizeof (struct pcb),
224: THREAD_CHUNK * sizeof (struct pcb),
225: FALSE, "pcb");
226: }
227:
228: /*
229: * Initialize a pcb for a
230: * new thread.
231: */
232: void pcb_init(
233: thread_t thread
234: )
235: {
236: struct pcb *pcb;
237: tss_t *tss;
238:
239: /*
240: * Allocate a new pcb.
241: */
242: thread->pcb = pcb = (void *)zalloc(pcb_zone);
243: *pcb = (struct pcb) { 0 };
244:
245: /*
246: * Setup with internal TSS.
247: */
248: pcb->tss = tss = &pcb->tss_store.internal;
249: pcb->tss_size = TSS_SIZE(0);
250:
251: /*
252: * Context from pmap.
253: */
254: tss->cr3 = vm_map_pmap(thread->task->map)->cr3;
255:
256: /*
257: * Setup with default LDT.
258: */
259: pcb->ldt = (vm_offset_t)ldt + KERNEL_LINEAR_BASE;
260: pcb->ldt_size = LDTSZ * sizeof (ldt_entry_t);
261:
262: tss->ldt = LDT_SEL;
263:
264: /*
265: * Kernel state.
266: */
267: tss->ss0 = KDS_SEL;
268: tss->eflags = EFL_IF;
269: tss->ss = KDS_SEL;
270: tss->cs = KCS_SEL;
271: tss->ds = KDS_SEL;
272: tss->es = KDS_SEL;
273: tss->fs = LDATA_SEL;
274: tss->gs = NULL_SEL;
275: tss->io_bmap = TSS_SIZE(0);
276: }
277:
278: void
279: pcb_common_init(
280: task_t task
281: )
282: {
283: pcb_common_t *common = (void *)kalloc(sizeof (*common));
284:
285: lock_init(&common->lock, TRUE);
286: common->ldt = (vm_offset_t)ldt + KERNEL_LINEAR_BASE;
287: common->ldt_size = LDTSZ * sizeof (ldt_entry_t);
288: common->io_bmap.length = common->io_bmap.base = 0;
289: task->pcb_common = common;
290: }
291:
292: /*
293: * Set the thread's io space to the region
294: * defined by base and length. The TSS is
295: * expanded if necessary. Thread must either
296: * be the current thread, or suspended.
297: * N.B. On exit, the thread is guaranteed to
298: * have an external TSS.
299: */
300: static void
301: thread_set_io_bmap(
302: thread_t thread,
303: vm_offset_t base,
304: vm_size_t length
305: )
306: {
307: struct pcb *pcb = thread->pcb;
308:
309: if (pcb->tss_size < TSS_SIZE(length + 1)) {
310: struct tss_alloc new_tss_alloc, old_tss_alloc;
311: tss_t *new_tss, *old_tss;
312:
313: /*
314: * TSS needs to be enlarged.
315: */
316: new_tss_alloc.length = TSS_SIZE(length + 1);
317: new_tss_alloc.base = (vm_offset_t)kalloc(new_tss_alloc.length);
318:
319: new_tss = (tss_t *)new_tss_alloc.base;
320: old_tss = pcb->tss;
321:
322: /*
323: * Copy old TSS to new one.
324: */
325: *new_tss = *old_tss;
326:
327: if (pcb->extern_tss) {
328: /*
329: * Deal with old external tss.
330: */
331: old_tss_alloc = pcb->tss_store.external;
332:
333: /*
334: * Switch to new TSS.
335: */
336: pcb->tss_store.external = new_tss_alloc;
337: pcb->tss = new_tss;
338: pcb->tss_size = new_tss_alloc.length;
339: pcb->extern_tss = TRUE;
340:
341: /*
342: * Free old TSS.
343: */
344: kfree((void *)old_tss_alloc.base, old_tss_alloc.length);
345: }
346: else {
347: /*
348: * Switch to new TSS.
349: */
350: pcb->tss_store.external = new_tss_alloc;
351: pcb->tss = new_tss;
352: pcb->tss_size = new_tss_alloc.length;
353: pcb->extern_tss = TRUE;
354: }
355:
356: /*
357: * If changing the current
358: * thread, remap its tss now.
359: */
360: if (thread == current_thread()) {
361: map_tss(sel_to_gdt_entry(TSS_SEL),
362: (vm_offset_t) thread->pcb->tss
363: + KERNEL_LINEAR_BASE,
364: (vm_size_t) thread->pcb->tss_size);
365: ltr();
366: }
367: }
368:
369: memcpy(
370: (void *)pcb->tss + pcb->tss->io_bmap,
371: (void *)base, length);
372: }
373:
374: static void
375: task_update_io_bmap(
376: task_t task
377: )
378: {
379: queue_head_t *list;
380: thread_t thread, prev_thread;
381: pcb_common_t *common = task->pcb_common;
382:
383: list = &task->thread_list;
384: prev_thread = THREAD_NULL;
385: task_lock(task);
386: thread = (thread_t)queue_first(list);
387: while (!queue_end(list, (queue_entry_t)thread)) {
388: thread_reference(thread);
389: task_unlock(task);
390: if (prev_thread != THREAD_NULL)
391: thread_deallocate(prev_thread);
392: thread_set_io_bmap(thread,
393: common->io_bmap.base,
394: common->io_bmap.length);
395: prev_thread = thread;
396: task_lock(task);
397: thread = (thread_t)queue_next(&thread->thread_list);
398: }
399: task_unlock(task);
400: if (prev_thread != THREAD_NULL)
401: thread_deallocate(prev_thread);
402: }
403:
404: kern_return_t
405: task_map_io_ports(
406: task_t task,
407: unsigned int port,
408: unsigned int length,
409: boolean_t unmap
410: )
411: {
412: pcb_common_t *common = task->pcb_common;
413: vm_offset_t new_io_bmap_base;
414: vm_size_t new_io_bmap_length;
415: int i;
416:
417: /*
418: * Bad port range.
419: */
420: if ((port + length) > 65536)
421: return (KERN_INVALID_ADDRESS);
422:
423: if (task->kernel_vm_space)
424: return (KERN_SUCCESS);
425:
426: /*
427: * If task is being terminated,
428: * don't bother.
429: */
430: if (task_hold(task) != KERN_SUCCESS)
431: return (KERN_INVALID_ARGUMENT);
432:
433: new_io_bmap_length = roundup(port + length, NBBY) / NBBY;
434:
435: lock_write(&common->lock);
436:
437: if (common->io_bmap.length < new_io_bmap_length) {
438: new_io_bmap_base = (vm_offset_t)kalloc(new_io_bmap_length);
439:
440: /*
441: * Invalidate all of new IO bitmap.
442: */
443: memset(
444: (void *)new_io_bmap_base,
445: 0xff, new_io_bmap_length);
446:
447: /*
448: * Copy old IO bitmap.
449: */
450: memcpy(
451: (void *)new_io_bmap_base,
452: (void *)common->io_bmap.base, common->io_bmap.length);
453:
454: kfree((void *)common->io_bmap.base, common->io_bmap.length);
455:
456: common->io_bmap.base = new_io_bmap_base;
457: common->io_bmap.length = new_io_bmap_length;
458: }
459:
460: for (i = port; i < (port + length); i++)
461: if (unmap)
462: setbit(common->io_bmap.base, i);
463: else
464: clrbit(common->io_bmap.base, i);
465:
466: (void) task_dowait(task, TRUE);
467:
468: task_update_io_bmap(task);
469:
470: (void) task_release(task);
471:
472: lock_done(&common->lock);
473:
474: return (KERN_SUCCESS);
475: }
476:
477: static void
478: thread_set_ldt(
479: thread_t thread,
480: vm_offset_t address,
481: vm_size_t size
482: )
483: {
484: thread->pcb->ldt = address;
485: thread->pcb->ldt_size = size;
486:
487: /*
488: * If changing the current
489: * thread, remap its LDT now.
490: */
491: if (thread == current_thread()) {
492: map_ldt(sel_to_gdt_entry(LDT_SEL),
493: (vm_offset_t) thread->pcb->ldt,
494: (vm_size_t) thread->pcb->ldt_size);
495: lldt();
496: }
497: }
498:
499: static void
500: task_update_ldt(
501: task_t task
502: )
503: {
504: queue_head_t *list;
505: thread_t thread, prev_thread;
506: pcb_common_t *common = task->pcb_common;
507:
508: list = &task->thread_list;
509: prev_thread = THREAD_NULL;
510: task_lock(task);
511: thread = (thread_t)queue_first(list);
512: while (!queue_end(list, (queue_entry_t)thread)) {
513: thread_reference(thread);
514: task_unlock(task);
515: if (prev_thread != THREAD_NULL)
516: thread_deallocate(prev_thread);
517: thread_set_ldt(thread, common->ldt, common->ldt_size);
518: prev_thread = thread;
519: task_lock(task);
520: thread = (thread_t)queue_next(&thread->thread_list);
521: }
522: task_unlock(task);
523: if (prev_thread != THREAD_NULL)
524: thread_deallocate(prev_thread);
525: }
526:
527: kern_return_t
528: task_locate_ldt(
529: task_t task,
530: vm_offset_t address,
531: vm_size_t size
532: )
533: {
534: pcb_common_t *common = task->pcb_common;
535:
536: if (vm_map_min(task->map) > address ||
537: vm_map_max(task->map) <= (address + size))
538: return (KERN_INVALID_ADDRESS);
539:
540: /*
541: * If task is being terminated,
542: * don't bother.
543: */
544: if (task_hold(task) != KERN_SUCCESS)
545: return (KERN_INVALID_ARGUMENT);
546:
547: lock_write(&common->lock);
548:
549: common->ldt = address;
550: common->ldt_size = size;
551:
552: (void) task_dowait(task, TRUE);
553:
554: task_update_ldt(task);
555:
556: (void) task_release(task);
557:
558: lock_done(&common->lock);
559:
560: return (KERN_SUCCESS);
561: }
562:
563: kern_return_t
564: task_default_ldt(
565: task_t task
566: )
567: {
568: pcb_common_t *common = task->pcb_common;
569:
570: /*
571: * If task is being terminated,
572: * don't bother.
573: */
574: if (task_hold(task) != KERN_SUCCESS)
575: return (KERN_INVALID_ARGUMENT);
576:
577: lock_write(&common->lock);
578:
579: common->ldt = (vm_offset_t)ldt + KERNEL_LINEAR_BASE;
580: common->ldt_size = LDTSZ * sizeof (ldt_entry_t);
581:
582: (void) task_dowait(task, TRUE);
583:
584: task_update_ldt(task);
585:
586: (void) task_release(task);
587:
588: lock_done(&common->lock);
589:
590: return (KERN_SUCCESS);
591: }
592:
593: thread_saved_state_t *
594: thread_user_state(
595: thread_t thread
596: )
597: {
598: thread_save_area_t *save_area = thread->pcb->save_area;
599:
600: if (save_area == 0) {
601: thread_saved_state_t *saved_state;
602:
603: thread->pcb->save_area =
604: save_area = (void *)kalloc(sizeof (*save_area));
605:
606: saved_state = &save_area->sa_u;
607: *saved_state = (thread_saved_state_t) { 0 };
608: saved_state->frame.eflags = EFL_IF;
609: saved_state->frame.cs = UCODE_SEL;
610: saved_state->frame.ss = UDATA_SEL;
611: saved_state->regs.ds = UDATA_SEL;
612: saved_state->regs.es = UDATA_SEL;
613: saved_state->regs.fs = NULL_SEL;
614: saved_state->regs.gs = NULL_SEL;
615:
616: return (saved_state);
617: }
618: else
619: return (&save_area->sa_u);
620: }
621:
622: /*
623: * Entry point for new user
624: * threads.
625: */
626: void
627: thread_bootstrap_return(void)
628: {
629: thread_t thread = current_thread();
630: pcb_common_t *common = thread->task->pcb_common;
631: struct pcb *pcb = thread->pcb;
632:
633: lock_read(&common->lock);
634:
635: if (common->io_bmap.length > 0)
636: thread_set_io_bmap(thread,
637: common->io_bmap.base,
638: common->io_bmap.length);
639:
640: if (common->ldt != pcb->ldt)
641: thread_set_ldt(thread, common->ldt, common->ldt_size);
642:
643: lock_done(&common->lock);
644:
645: thread_exception_return();
646: /* NOTREACHED */
647: }
648:
649: void
650: thread_exception_return(void)
651: {
652: thread_t thread = current_thread();
653: thread_saved_state_t *saved_state = USER_REGS(thread);
654:
655: check_for_ast(saved_state); // *may* not return
656:
657: thread->pcb->tss->esp0 =
658: ((saved_state->frame.eflags & EFL_VM) ?
659: KERNEL_V86_STACK_BASE(saved_state) :
660: KERNEL_STACK_BASE(saved_state));
661:
662: _return_with_state(saved_state);
663: /* NOTREACHED */
664: }
665:
666: void __volatile__
667: thread_syscall_return(
668: kern_return_t result
669: )
670: {
671: thread_t thread = current_thread();
672: thread_saved_state_t *saved_state = USER_REGS(thread);
673:
674: saved_state->regs.eax = result;
675:
676: check_for_ast(saved_state); // *may* not return
677:
678: thread->pcb->tss->esp0 =
679: ((saved_state->frame.eflags & EFL_VM) ?
680: KERNEL_V86_STACK_BASE(saved_state) :
681: KERNEL_STACK_BASE(saved_state));
682:
683: _return_with_state(saved_state);
684: /* NOTREACHED */
685: }
686:
687: void
688: thread_set_syscall_return(
689: thread_t thread,
690: kern_return_t result
691: )
692: {
693: thread_saved_state_t *saved_state = USER_REGS(thread);
694:
695: saved_state->regs.eax = result;
696: }
697:
698: /*
699: * Called from locore to
700: * startup the first thread. (never returns)
701: */
702: void
703: start_initial_context(
704: thread_t thread
705: )
706: {
707: struct pcb *pcb = thread->pcb;
708:
709: /*
710: * Initialize the common,
711: * static LDT.
712: */
713: ldt_init();
714:
715: /*
716: * Change software state.
717: */
718: PMAP_ACTIVATE(vm_map_pmap(thread->task->map), thread, 0);
719:
720: current_thread() = thread;
721: current_stack() = thread->kernel_stack;
722: current_stack_pointer() = thread->kernel_stack + KERNEL_STACK_SIZE;
723:
724: /*
725: * Change hardware state.
726: */
727: set_cr3(pcb->tss->cr3);
728:
729: map_ldt(sel_to_gdt_entry(LDT_SEL),
730: (vm_offset_t) pcb->ldt,
731: (vm_size_t) pcb->ldt_size);
732: lldt();
733:
734: map_tss(sel_to_gdt_entry(TSS_SEL),
735: (vm_offset_t) pcb->tss
736: + KERNEL_LINEAR_BASE,
737: (vm_size_t) pcb->tss_size);
738: ltr(); setts();
739:
740: _switch_tss(0, pcb->tss, 0);
741: }
742:
743: /*
744: * Set externally visible thread
745: * state.
746: */
747: kern_return_t
748: thread_setstatus(
749: thread_t thread,
750: int flavor,
751: thread_state_t tstate,
752: unsigned int count
753: )
754: {
755: switch (flavor) {
756:
757: case i386_THREAD_STATE:
758: return (set_thread_state(thread, tstate, count));
759:
760: case i386_THREAD_FPSTATE:
761: return (set_thread_fpstate(thread, tstate, count));
762:
763: default:
764: return (KERN_INVALID_ARGUMENT);
765: }
766: }
767:
768: static void set_thread_v86_state(
769: thread_t thread,
770: i386_thread_state_t *state);
771:
772: kern_return_t
773: set_thread_state(
774: thread_t thread,
775: thread_state_t tstate,
776: unsigned int count
777: )
778: {
779: thread_saved_state_t *saved_state;
780: i386_thread_state_t *state;
781:
782: if (count < i386_THREAD_STATE_COUNT)
783: return (KERN_INVALID_ARGUMENT);
784:
785: state = (i386_thread_state_t *)tstate;
786:
787: if ((state->eflags & EFL_VM) != 0)
788: set_thread_v86_state(thread, state);
789: else {
790: if (!thread->task->kernel_privilege) {
791: /*
792: * Validate segment selector values.
793: */
794: if (
795: !valid_user_code_selector(state->cs) ||
796: !valid_user_data_selector(state->ds) ||
797: !valid_user_data_selector(state->es) ||
798: !valid_user_data_selector(state->fs) ||
799: !valid_user_data_selector(state->gs) ||
800: !valid_user_stack_selector(state->ss)
801: )
802: return (KERN_INVALID_ARGUMENT);
803: }
804: else {
805: tss_t *tss = thread->pcb->tss;
806: /*
807: * State for kernel threads
808: * can only be set before thread
809: * is first started.
810: *
811: * XXX This hack is due to the
812: * fact that the &^%$#@! kernel loader
813: * uses the thread_set_state() call to
814: * start a thread in kernel mode.
815: */
816: if (thread->swap_func != thread_bootstrap_return)
817: return (KERN_INVALID_ARGUMENT);
818:
819: tss->eax = state->eax;
820: tss->ebx = state->ebx;
821: tss->ecx = state->ecx;
822: tss->edx = state->edx;
823: tss->edi = state->edi;
824: tss->esi = state->esi;
825:
826: thread_start(thread, state->eip);
827:
828: return (KERN_SUCCESS);
829: }
830:
831: saved_state = USER_REGS(thread);
832:
833: saved_state->regs.eax = state->eax;
834: saved_state->regs.ebx = state->ebx;
835: saved_state->regs.ecx = state->ecx;
836: saved_state->regs.edx = state->edx;
837: saved_state->regs.edi = state->edi;
838: saved_state->regs.esi = state->esi;
839: saved_state->regs.ebp = state->ebp;
840: saved_state->frame.esp = state->esp;
841: saved_state->frame.ss = selector_to_sel(state->ss);
842: saved_state->frame.eflags = state->eflags;
843: saved_state->frame.eflags &= ~( EFL_VM | EFL_NT | EFL_IOPL | EFL_CLR );
844: saved_state->frame.eflags |= ( EFL_IF | EFL_SET );
845: saved_state->frame.eip = state->eip;
846: saved_state->frame.cs = selector_to_sel(state->cs);
847: saved_state->regs.ds = selector_to_sel(state->ds);
848: saved_state->regs.es = selector_to_sel(state->es);
849: saved_state->regs.fs = selector_to_sel(state->fs);
850: saved_state->regs.gs = selector_to_sel(state->gs);
851: }
852:
853: return (KERN_SUCCESS);
854: }
855:
856: static
857: void
858: set_thread_v86_state(
859: thread_t thread,
860: i386_thread_state_t *state
861: )
862: {
863: thread_saved_state_t *saved_state = USER_REGS(thread);
864:
865: saved_state->regs.eax = state->eax;
866: saved_state->regs.ebx = state->ebx;
867: saved_state->regs.ecx = state->ecx;
868: saved_state->regs.edx = state->edx;
869: saved_state->regs.edi = state->edi;
870: saved_state->regs.esi = state->esi;
871: saved_state->regs.ebp = state->ebp;
872: saved_state->frame.esp = state->esp;
873: saved_state->frame.ss = selector_to_sel(state->ss);
874: saved_state->frame.eflags = state->eflags;
875: saved_state->frame.eflags &= ~( EFL_NT | EFL_IOPL | EFL_CLR );
876: saved_state->frame.eflags |= ( EFL_VM | EFL_IF | EFL_SET );
877: saved_state->frame.eip = state->eip;
878: saved_state->frame.cs = selector_to_sel(state->cs);
879: saved_state->regs.ds = NULL_SEL;
880: saved_state->regs.es = NULL_SEL;
881: saved_state->regs.fs = NULL_SEL;
882: saved_state->regs.gs = NULL_SEL;
883: saved_state->frame.v_ds = state->ds;
884: saved_state->frame.v_es = state->es;
885: saved_state->frame.v_fs = state->fs;
886: saved_state->frame.v_gs = state->gs;
887: }
888:
889: kern_return_t
890: set_thread_fpstate(
891: thread_t thread,
892: thread_state_t tstate,
893: unsigned int count
894: )
895: {
896: fp_state_t *saved_state;
897: i386_thread_fpstate_t *state;
898:
899: if (count < i386_THREAD_FPSTATE_COUNT)
900: return (KERN_INVALID_ARGUMENT);
901:
902: state = (i386_thread_fpstate_t *)tstate;
903: saved_state = &thread->pcb->fpstate;
904:
905: fp_terminate(thread);
906:
907: saved_state->environ = state->environ;
908: saved_state->stack = state->stack;
909:
910: thread->pcb->fpvalid = TRUE;
911:
912: return (KERN_SUCCESS);
913: }
914:
915: kern_return_t
916: thread_set_cthread_self(
917: int self
918: )
919: {
920: current_thread()->pcb->cthread_self = (unsigned int)self;
921:
922: return (KERN_SUCCESS);
923: }
924:
925: /*
926: * Return externally visible
927: * thread status.
928: */
929: kern_return_t
930: thread_getstatus(
931: thread_t thread,
932: int flavor,
933: thread_state_t tstate,
934: unsigned int *count
935: )
936: {
937: switch (flavor) {
938:
939: case i386_THREAD_STATE:
940: return (get_thread_state(thread, tstate, count));
941:
942: case i386_THREAD_FPSTATE:
943: return (get_thread_fpstate(thread, tstate, count));
944:
945: case i386_THREAD_EXCEPTSTATE:
946: return (get_thread_exceptstate(thread, tstate, count));
947:
948: case i386_THREAD_CTHREADSTATE:
949: return (get_thread_cthreadstate(thread, tstate, count));
950:
951: case THREAD_STATE_FLAVOR_LIST:
952: return (get_thread_state_flavor_list(tstate, count));
953:
954: default:
955: return (KERN_INVALID_ARGUMENT);
956: }
957: }
958:
959: kern_return_t
960: get_thread_state(
961: thread_t thread,
962: thread_state_t tstate,
963: unsigned int *count
964: )
965: {
966: thread_saved_state_t *saved_state;
967: i386_thread_state_t *state;
968:
969: if (*count < i386_THREAD_STATE_COUNT)
970: return (KERN_INVALID_ARGUMENT);
971:
972: state = (i386_thread_state_t *)tstate;
973: saved_state = USER_REGS(thread);
974:
975: state->eax = saved_state->regs.eax;
976: state->ebx = saved_state->regs.ebx;
977: state->ecx = saved_state->regs.ecx;
978: state->edx = saved_state->regs.edx;
979: state->edi = saved_state->regs.edi;
980: state->esi = saved_state->regs.esi;
981: state->ebp = saved_state->regs.ebp;
982: state->esp = saved_state->frame.esp;
983: state->ss = sel_to_selector(saved_state->frame.ss);
984: state->eflags = saved_state->frame.eflags;
985: state->eip = saved_state->frame.eip;
986: state->cs = sel_to_selector(saved_state->frame.cs);
987: if ((saved_state->frame.eflags & EFL_VM) == 0) {
988: state->ds = sel_to_selector(saved_state->regs.ds);
989: state->es = sel_to_selector(saved_state->regs.es);
990: state->fs = sel_to_selector(saved_state->regs.fs);
991: state->gs = sel_to_selector(saved_state->regs.gs);
992: }
993: else {
994: state->ds = saved_state->frame.v_ds;
995: state->es = saved_state->frame.v_es;
996: state->fs = saved_state->frame.v_fs;
997: state->gs = saved_state->frame.v_gs;
998: }
999:
1000: *count = i386_THREAD_STATE_COUNT;
1001:
1002: return (KERN_SUCCESS);
1003: }
1004:
1005: kern_return_t
1006: get_thread_fpstate(
1007: thread_t thread,
1008: thread_state_t tstate,
1009: unsigned int *count
1010: )
1011: {
1012: fp_state_t *saved_state;
1013: i386_thread_fpstate_t *state;
1014:
1015: if (*count < i386_THREAD_FPSTATE_COUNT)
1016: return (KERN_INVALID_ARGUMENT);
1017:
1018: state = (i386_thread_fpstate_t *)tstate;
1019: saved_state = &thread->pcb->fpstate;
1020:
1021: fp_synch(thread);
1022:
1023: state->environ = saved_state->environ;
1024: state->stack = saved_state->stack;
1025:
1026: *count = i386_THREAD_FPSTATE_COUNT;
1027:
1028: return (KERN_SUCCESS);
1029: }
1030:
1031: kern_return_t
1032: get_thread_exceptstate(
1033: thread_t thread,
1034: thread_state_t tstate,
1035: unsigned int *count
1036: )
1037: {
1038: thread_saved_state_t *saved_state;
1039: i386_thread_exceptstate_t *state;
1040:
1041: if (*count < i386_THREAD_EXCEPTSTATE_COUNT)
1042: return (KERN_INVALID_ARGUMENT);
1043:
1044: state = (i386_thread_exceptstate_t *)tstate;
1045: saved_state = USER_REGS(thread);
1046:
1047: state->trapno = saved_state->trapno;
1048: state->err = saved_state->frame.err;
1049:
1050: *count = i386_THREAD_EXCEPTSTATE_COUNT;
1051:
1052: return (KERN_SUCCESS);
1053: }
1054:
1055: kern_return_t
1056: get_thread_cthreadstate(
1057: thread_t thread,
1058: thread_state_t tstate,
1059: unsigned int *count
1060: )
1061: {
1062: i386_thread_cthreadstate_t *state;
1063:
1064: if (*count < i386_THREAD_CTHREADSTATE_COUNT)
1065: return (KERN_INVALID_ARGUMENT);
1066:
1067: state = (i386_thread_cthreadstate_t *)tstate;
1068: state->self = thread->pcb->cthread_self;
1069:
1070: *count = i386_THREAD_CTHREADSTATE_COUNT;
1071:
1072: return (KERN_SUCCESS);
1073: }
1074:
1075: kern_return_t
1076: thread_get_cthread_self(
1077: void
1078: )
1079: {
1080: return ((kern_return_t)current_thread()->pcb->cthread_self);
1081: }
1082:
1083: kern_return_t
1084: get_thread_state_flavor_list(
1085: thread_state_t tstate,
1086: unsigned int *count
1087: )
1088: {
1089: struct thread_state_flavor *state;
1090: #define i386_THREAD_STATE_FLAVOR_COUNT 4
1091:
1092: #define i386_THREAD_STATE_FLAVOR_LIST_COUNT \
1093: ( i386_THREAD_STATE_FLAVOR_COUNT * \
1094: ( sizeof (struct thread_state_flavor) / sizeof (int) ) )
1095:
1096: if (*count < i386_THREAD_STATE_FLAVOR_COUNT)
1097: return (KERN_INVALID_ARGUMENT);
1098:
1099: state = (struct thread_state_flavor *)tstate;
1100:
1101: state->flavor = i386_THREAD_STATE;
1102: state->count = i386_THREAD_STATE_COUNT;
1103:
1104: (++state)->flavor = i386_THREAD_FPSTATE;
1105: state->count = i386_THREAD_FPSTATE_COUNT;
1106:
1107: (++state)->flavor = i386_THREAD_EXCEPTSTATE;
1108: state->count = i386_THREAD_EXCEPTSTATE_COUNT;
1109:
1110: (++state)->flavor = i386_THREAD_CTHREADSTATE;
1111: state->count = i386_THREAD_CTHREADSTATE_COUNT;
1112:
1113: *count = i386_THREAD_STATE_FLAVOR_LIST_COUNT;
1114:
1115: return (KERN_SUCCESS);
1116: }
1117:
1118: /*
1119: * thread_userstack:
1120: *
1121: * Return the user stack pointer from the machine dependent thread state info.
1122: */
1123: kern_return_t
1124: thread_userstack(
1125: thread_t thread,
1126: int flavor,
1127: thread_state_t tstate,
1128: unsigned int count,
1129: vm_offset_t *user_stack
1130: )
1131: {
1132: i386_thread_state_t *state;
1133:
1134: /*
1135: * Set a default.
1136: */
1137: if (*user_stack == 0)
1138: *user_stack = VM_MAX_ADDRESS;
1139:
1140: switch (flavor) {
1141:
1142: case i386_THREAD_STATE:
1143: if (count < i386_THREAD_STATE_COUNT)
1144: return (KERN_INVALID_ARGUMENT);
1145:
1146: state = (i386_thread_state_t *) tstate;
1147:
1148: /*
1149: * If a valid user stack is specified, use it.
1150: */
1151: *user_stack = state->esp ? state->esp: VM_MAX_ADDRESS;
1152: break;
1153: }
1154:
1155: return (KERN_SUCCESS);
1156: }
1157: kern_return_t
1158: thread_entrypoint(
1159: thread_t thread,
1160: int flavor,
1161: thread_state_t tstate,
1162: unsigned int count,
1163: vm_offset_t *entry_point
1164: )
1165: {
1166: i386_thread_state_t *state;
1167:
1168: /*
1169: * Set a default.
1170: */
1171: if (*entry_point == 0)
1172: *entry_point = VM_MIN_ADDRESS;
1173:
1174: switch (flavor) {
1175:
1176: case i386_THREAD_STATE:
1177: if (count < i386_THREAD_STATE_COUNT)
1178: return (KERN_INVALID_ARGUMENT);
1179:
1180: state = (i386_thread_state_t *) tstate;
1181:
1182: /*
1183: * If a valid entry point is specified, use it.
1184: */
1185: *entry_point = state->eip ? state->eip: VM_MIN_ADDRESS;
1186: break;
1187: }
1188:
1189: return (KERN_SUCCESS);
1190: }
1191:
1192: /*
1193: * Duplicate parent state in child
1194: * for U**X fork.
1195: */
1196: thread_dup(
1197: thread_t parent,
1198: thread_t child
1199: )
1200: {
1201: struct thread_saved_state *parent_state, *child_state;
1202:
1203: parent_state = USER_REGS(parent);
1204: child_state = thread_user_state(child);
1205:
1206: *child_state = *parent_state;
1207:
1208: child_state->regs.eax = child->task->proc->p_pid;
1209:
1210: child_state->regs.edx = 1;
1211: child_state->frame.eflags &= ~EFL_CF;
1212: }
1213:
1214: /*
1215: * Release resources on
1216: * thread termination.
1217: */
1218: pcb_terminate(
1219: thread_t thread
1220: )
1221: {
1222: struct pcb *pcb = thread->pcb;
1223:
1224: /*
1225: * Give up the fpu if
1226: * necessary.
1227: */
1228: fp_terminate(thread);
1229:
1230: #if PC_SUPPORT
1231: if (pcb->PCpriv)
1232: PCdestroy(thread);
1233: #endif
1234:
1235: /*
1236: * Free save area.
1237: */
1238: if (pcb->save_area)
1239: kfree((void *)pcb->save_area,
1240: sizeof (*pcb->save_area));
1241:
1242: /*
1243: * Free external tss.
1244: */
1245: if (pcb->extern_tss)
1246: kfree(
1247: (void *)pcb->tss_store.external.base,
1248: pcb->tss_store.external.length);
1249:
1250: thread->pcb = 0;
1251: zfree(pcb_zone, pcb);
1252: }
1253:
1254: /*
1255: * Synchronize pcb with
1256: * hardware state.
1257: */
1258: pcb_synch(
1259: thread_t thread
1260: )
1261: {
1262: /*
1263: * Write out our fp state
1264: * if necessary.
1265: */
1266: fp_synch(thread);
1267: }
1268:
1269: void
1270: pcb_common_terminate(
1271: task_t task
1272: )
1273: {
1274: pcb_common_t *common = task->pcb_common;
1275:
1276: kfree((void *)common, sizeof (*common));
1277: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.