lguest: the host code
[linux-2.6.git] / drivers / lguest / segments.c
1 #include "lg.h"
2
3 static int desc_ok(const struct desc_struct *gdt)
4 {
5         /* MBZ=0, P=1, DT=1  */
6         return ((gdt->b & 0x00209000) == 0x00009000);
7 }
8
9 static int segment_present(const struct desc_struct *gdt)
10 {
11         return gdt->b & 0x8000;
12 }
13
14 static int ignored_gdt(unsigned int num)
15 {
16         return (num == GDT_ENTRY_TSS
17                 || num == GDT_ENTRY_LGUEST_CS
18                 || num == GDT_ENTRY_LGUEST_DS
19                 || num == GDT_ENTRY_DOUBLEFAULT_TSS);
20 }
21
22 /* We don't allow removal of CS, DS or SS; it doesn't make sense. */
23 static void check_segment_use(struct lguest *lg, unsigned int desc)
24 {
25         if (lg->regs->gs / 8 == desc)
26                 lg->regs->gs = 0;
27         if (lg->regs->fs / 8 == desc)
28                 lg->regs->fs = 0;
29         if (lg->regs->es / 8 == desc)
30                 lg->regs->es = 0;
31         if (lg->regs->ds / 8 == desc
32             || lg->regs->cs / 8 == desc
33             || lg->regs->ss / 8 == desc)
34                 kill_guest(lg, "Removed live GDT entry %u", desc);
35 }
36
37 static void fixup_gdt_table(struct lguest *lg, unsigned start, unsigned end)
38 {
39         unsigned int i;
40
41         for (i = start; i < end; i++) {
42                 /* We never copy these ones to real gdt */
43                 if (ignored_gdt(i))
44                         continue;
45
46                 /* We could fault in switch_to_guest if they are using
47                  * a removed segment. */
48                 if (!segment_present(&lg->gdt[i])) {
49                         check_segment_use(lg, i);
50                         continue;
51                 }
52
53                 if (!desc_ok(&lg->gdt[i]))
54                         kill_guest(lg, "Bad GDT descriptor %i", i);
55
56                 /* DPL 0 presumably means "for use by guest". */
57                 if ((lg->gdt[i].b & 0x00006000) == 0)
58                         lg->gdt[i].b |= (GUEST_PL << 13);
59
60                 /* Set accessed bit, since gdt isn't writable. */
61                 lg->gdt[i].b |= 0x00000100;
62         }
63 }
64
65 void setup_default_gdt_entries(struct lguest_ro_state *state)
66 {
67         struct desc_struct *gdt = state->guest_gdt;
68         unsigned long tss = (unsigned long)&state->guest_tss;
69
70         /* Hypervisor segments. */
71         gdt[GDT_ENTRY_LGUEST_CS] = FULL_EXEC_SEGMENT;
72         gdt[GDT_ENTRY_LGUEST_DS] = FULL_SEGMENT;
73
74         /* This is the one which we *cannot* copy from guest, since tss
75            is depended on this lguest_ro_state, ie. this cpu. */
76         gdt[GDT_ENTRY_TSS].a = 0x00000067 | (tss << 16);
77         gdt[GDT_ENTRY_TSS].b = 0x00008900 | (tss & 0xFF000000)
78                 | ((tss >> 16) & 0x000000FF);
79 }
80
81 void setup_guest_gdt(struct lguest *lg)
82 {
83         lg->gdt[GDT_ENTRY_KERNEL_CS] = FULL_EXEC_SEGMENT;
84         lg->gdt[GDT_ENTRY_KERNEL_DS] = FULL_SEGMENT;
85         lg->gdt[GDT_ENTRY_KERNEL_CS].b |= (GUEST_PL << 13);
86         lg->gdt[GDT_ENTRY_KERNEL_DS].b |= (GUEST_PL << 13);
87 }
88
89 /* This is a fast version for the common case where only the three TLS entries
90  * have changed. */
91 void copy_gdt_tls(const struct lguest *lg, struct desc_struct *gdt)
92 {
93         unsigned int i;
94
95         for (i = GDT_ENTRY_TLS_MIN; i <= GDT_ENTRY_TLS_MAX; i++)
96                 gdt[i] = lg->gdt[i];
97 }
98
99 void copy_gdt(const struct lguest *lg, struct desc_struct *gdt)
100 {
101         unsigned int i;
102
103         for (i = 0; i < GDT_ENTRIES; i++)
104                 if (!ignored_gdt(i))
105                         gdt[i] = lg->gdt[i];
106 }
107
108 void load_guest_gdt(struct lguest *lg, unsigned long table, u32 num)
109 {
110         if (num > ARRAY_SIZE(lg->gdt))
111                 kill_guest(lg, "too many gdt entries %i", num);
112
113         lgread(lg, lg->gdt, table, num * sizeof(lg->gdt[0]));
114         fixup_gdt_table(lg, 0, ARRAY_SIZE(lg->gdt));
115         lg->changed |= CHANGED_GDT;
116 }
117
118 void guest_load_tls(struct lguest *lg, unsigned long gtls)
119 {
120         struct desc_struct *tls = &lg->gdt[GDT_ENTRY_TLS_MIN];
121
122         lgread(lg, tls, gtls, sizeof(*tls)*GDT_ENTRY_TLS_ENTRIES);
123         fixup_gdt_table(lg, GDT_ENTRY_TLS_MIN, GDT_ENTRY_TLS_MAX+1);
124         lg->changed |= CHANGED_GDT_TLS;
125 }