1 #include "userprog/tss.h"
4 #include "userprog/gdt.h"
5 #include "threads/thread.h"
6 #include "threads/palloc.h"
7 #include "threads/vaddr.h"
9 /* The Task-State Segment (TSS).
11 Instances of the TSS, an x86-specific structure, are used to
12 define "tasks", a form of support for multitasking built right
13 into the processor. However, for various reasons including
14 portability, speed, and flexibility, most x86 OSes almost
15 completely ignore the TSS. We are no exception.
17 Unfortunately, there is one thing that can only be done using
18 a TSS: stack switching for interrupts that occur in user mode.
19 When an interrupt occurs in user mode (ring 3), the processor
20 consults the ss0 and esp0 members of the current TSS to
21 determine the stack to use for handling the interrupt. Thus,
22 we must create a TSS and initialize at least these fields, and
23 this is precisely what this file does.
25 When an interrupt is handled by an interrupt or trap gate
26 (which applies to all interrupts we handle), an x86 processor
29 - If the code interrupted by the interrupt is in the same
30 ring as the interrupt handler, then no stack switch takes
31 place. This is the case for interrupts that happen when
32 we're running in the kernel. The contents of the TSS are
33 irrelevant for this case.
35 - If the interrupted code is in a different ring from the
36 handler, then the processor switches to the stack
37 specified in the TSS for the new ring. This is the case
38 for interrupts that happen when we're in user space. It's
39 important that we switch to a stack that's not already in
40 use, to avoid corruption. Because we're running in user
41 space, we know that the current process's kernel stack is
42 not in use, so we can always use that. Thus, when the
43 scheduler switches threads, it also changes the TSS's
44 stack pointer to point to the new thread's kernel stack.
45 (The call is in thread_schedule_tail() in thread.c.)
47 See [IA32-v3a] 6.2.1 "Task-State Segment (TSS)" for a
48 description of the TSS. See [IA32-v3a] 5.12.1 "Exception- or
49 Interrupt-Handler Procedures" for a description of when and
50 how stack switching occurs during an interrupt. */
53 uint16_t back_link, :16;
54 void *esp0; /* Ring 0 stack virtual address. */
55 uint16_t ss0, :16; /* Ring 0 stack segment selector. */
63 uint32_t eax, ecx, edx, ebx;
64 uint32_t esp, ebp, esi, edi;
72 uint16_t trace, bitmap;
76 static struct tss *tss;
78 /* Initializes the kernel TSS. */
82 /* Our TSS is never used in a call gate or task gate, so only a
83 few fields of it are ever referenced, and those are the only
84 ones we initialize. */
85 tss = palloc_get_page (PAL_ASSERT | PAL_ZERO);
91 /* Returns the kernel TSS. */
99 /* Sets the ring 0 stack pointer in the TSS to point to the end
100 of the thread stack. */
104 ASSERT (tss != NULL);
105 tss->esp0 = (uint8_t *) thread_current () + PGSIZE;