diff options
-rw-r--r-- | drivers/lguest/core.c | 24 | ||||
-rw-r--r-- | drivers/lguest/hypercalls.c | 49 | ||||
-rw-r--r-- | drivers/lguest/interrupts_and_traps.c | 54 | ||||
-rw-r--r-- | drivers/lguest/lg.h | 28 | ||||
-rw-r--r-- | drivers/lguest/page_tables.c | 115 | ||||
-rw-r--r-- | drivers/lguest/segments.c | 8 | ||||
-rw-r--r-- | drivers/lguest/x86/core.c | 30 |
7 files changed, 149 insertions, 159 deletions
diff --git a/drivers/lguest/core.c b/drivers/lguest/core.c index 6023872e32d0..7743d73768df 100644 --- a/drivers/lguest/core.c +++ b/drivers/lguest/core.c | |||
@@ -151,23 +151,23 @@ int lguest_address_ok(const struct lguest *lg, | |||
151 | /* This routine copies memory from the Guest. Here we can see how useful the | 151 | /* This routine copies memory from the Guest. Here we can see how useful the |
152 | * kill_lguest() routine we met in the Launcher can be: we return a random | 152 | * kill_lguest() routine we met in the Launcher can be: we return a random |
153 | * value (all zeroes) instead of needing to return an error. */ | 153 | * value (all zeroes) instead of needing to return an error. */ |
154 | void __lgread(struct lguest *lg, void *b, unsigned long addr, unsigned bytes) | 154 | void __lgread(struct lg_cpu *cpu, void *b, unsigned long addr, unsigned bytes) |
155 | { | 155 | { |
156 | if (!lguest_address_ok(lg, addr, bytes) | 156 | if (!lguest_address_ok(cpu->lg, addr, bytes) |
157 | || copy_from_user(b, lg->mem_base + addr, bytes) != 0) { | 157 | || copy_from_user(b, cpu->lg->mem_base + addr, bytes) != 0) { |
158 | /* copy_from_user should do this, but as we rely on it... */ | 158 | /* copy_from_user should do this, but as we rely on it... */ |
159 | memset(b, 0, bytes); | 159 | memset(b, 0, bytes); |
160 | kill_guest(lg, "bad read address %#lx len %u", addr, bytes); | 160 | kill_guest(cpu, "bad read address %#lx len %u", addr, bytes); |
161 | } | 161 | } |
162 | } | 162 | } |
163 | 163 | ||
164 | /* This is the write (copy into guest) version. */ | 164 | /* This is the write (copy into guest) version. */ |
165 | void __lgwrite(struct lguest *lg, unsigned long addr, const void *b, | 165 | void __lgwrite(struct lg_cpu *cpu, unsigned long addr, const void *b, |
166 | unsigned bytes) | 166 | unsigned bytes) |
167 | { | 167 | { |
168 | if (!lguest_address_ok(lg, addr, bytes) | 168 | if (!lguest_address_ok(cpu->lg, addr, bytes) |
169 | || copy_to_user(lg->mem_base + addr, b, bytes) != 0) | 169 | || copy_to_user(cpu->lg->mem_base + addr, b, bytes) != 0) |
170 | kill_guest(lg, "bad write address %#lx len %u", addr, bytes); | 170 | kill_guest(cpu, "bad write address %#lx len %u", addr, bytes); |
171 | } | 171 | } |
172 | /*:*/ | 172 | /*:*/ |
173 | 173 | ||
@@ -176,10 +176,8 @@ void __lgwrite(struct lguest *lg, unsigned long addr, const void *b, | |||
176 | * going around and around until something interesting happens. */ | 176 | * going around and around until something interesting happens. */ |
177 | int run_guest(struct lg_cpu *cpu, unsigned long __user *user) | 177 | int run_guest(struct lg_cpu *cpu, unsigned long __user *user) |
178 | { | 178 | { |
179 | struct lguest *lg = cpu->lg; | ||
180 | |||
181 | /* We stop running once the Guest is dead. */ | 179 | /* We stop running once the Guest is dead. */ |
182 | while (!lg->dead) { | 180 | while (!cpu->lg->dead) { |
183 | /* First we run any hypercalls the Guest wants done. */ | 181 | /* First we run any hypercalls the Guest wants done. */ |
184 | if (cpu->hcall) | 182 | if (cpu->hcall) |
185 | do_hypercalls(cpu); | 183 | do_hypercalls(cpu); |
@@ -212,7 +210,7 @@ int run_guest(struct lg_cpu *cpu, unsigned long __user *user) | |||
212 | 210 | ||
213 | /* Just make absolutely sure the Guest is still alive. One of | 211 | /* Just make absolutely sure the Guest is still alive. One of |
214 | * those hypercalls could have been fatal, for example. */ | 212 | * those hypercalls could have been fatal, for example. */ |
215 | if (lg->dead) | 213 | if (cpu->lg->dead) |
216 | break; | 214 | break; |
217 | 215 | ||
218 | /* If the Guest asked to be stopped, we sleep. The Guest's | 216 | /* If the Guest asked to be stopped, we sleep. The Guest's |
@@ -237,7 +235,7 @@ int run_guest(struct lg_cpu *cpu, unsigned long __user *user) | |||
237 | lguest_arch_handle_trap(cpu); | 235 | lguest_arch_handle_trap(cpu); |
238 | } | 236 | } |
239 | 237 | ||
240 | if (lg->dead == ERR_PTR(-ERESTART)) | 238 | if (cpu->lg->dead == ERR_PTR(-ERESTART)) |
241 | return -ERESTART; | 239 | return -ERESTART; |
242 | /* The Guest is dead => "No such file or directory" */ | 240 | /* The Guest is dead => "No such file or directory" */ |
243 | return -ENOENT; | 241 | return -ENOENT; |
diff --git a/drivers/lguest/hypercalls.c b/drivers/lguest/hypercalls.c index 0471018d700d..32666d0d956a 100644 --- a/drivers/lguest/hypercalls.c +++ b/drivers/lguest/hypercalls.c | |||
@@ -31,8 +31,6 @@ | |||
31 | * Or gets killed. Or, in the case of LHCALL_CRASH, both. */ | 31 | * Or gets killed. Or, in the case of LHCALL_CRASH, both. */ |
32 | static void do_hcall(struct lg_cpu *cpu, struct hcall_args *args) | 32 | static void do_hcall(struct lg_cpu *cpu, struct hcall_args *args) |
33 | { | 33 | { |
34 | struct lguest *lg = cpu->lg; | ||
35 | |||
36 | switch (args->arg0) { | 34 | switch (args->arg0) { |
37 | case LHCALL_FLUSH_ASYNC: | 35 | case LHCALL_FLUSH_ASYNC: |
38 | /* This call does nothing, except by breaking out of the Guest | 36 | /* This call does nothing, except by breaking out of the Guest |
@@ -41,7 +39,7 @@ static void do_hcall(struct lg_cpu *cpu, struct hcall_args *args) | |||
41 | case LHCALL_LGUEST_INIT: | 39 | case LHCALL_LGUEST_INIT: |
42 | /* You can't get here unless you're already initialized. Don't | 40 | /* You can't get here unless you're already initialized. Don't |
43 | * do that. */ | 41 | * do that. */ |
44 | kill_guest(lg, "already have lguest_data"); | 42 | kill_guest(cpu, "already have lguest_data"); |
45 | break; | 43 | break; |
46 | case LHCALL_SHUTDOWN: { | 44 | case LHCALL_SHUTDOWN: { |
47 | /* Shutdown is such a trivial hypercall that we do it in four | 45 | /* Shutdown is such a trivial hypercall that we do it in four |
@@ -49,11 +47,11 @@ static void do_hcall(struct lg_cpu *cpu, struct hcall_args *args) | |||
49 | char msg[128]; | 47 | char msg[128]; |
50 | /* If the lgread fails, it will call kill_guest() itself; the | 48 | /* If the lgread fails, it will call kill_guest() itself; the |
51 | * kill_guest() with the message will be ignored. */ | 49 | * kill_guest() with the message will be ignored. */ |
52 | __lgread(lg, msg, args->arg1, sizeof(msg)); | 50 | __lgread(cpu, msg, args->arg1, sizeof(msg)); |
53 | msg[sizeof(msg)-1] = '\0'; | 51 | msg[sizeof(msg)-1] = '\0'; |
54 | kill_guest(lg, "CRASH: %s", msg); | 52 | kill_guest(cpu, "CRASH: %s", msg); |
55 | if (args->arg2 == LGUEST_SHUTDOWN_RESTART) | 53 | if (args->arg2 == LGUEST_SHUTDOWN_RESTART) |
56 | lg->dead = ERR_PTR(-ERESTART); | 54 | cpu->lg->dead = ERR_PTR(-ERESTART); |
57 | break; | 55 | break; |
58 | } | 56 | } |
59 | case LHCALL_FLUSH_TLB: | 57 | case LHCALL_FLUSH_TLB: |
@@ -74,10 +72,10 @@ static void do_hcall(struct lg_cpu *cpu, struct hcall_args *args) | |||
74 | guest_set_stack(cpu, args->arg1, args->arg2, args->arg3); | 72 | guest_set_stack(cpu, args->arg1, args->arg2, args->arg3); |
75 | break; | 73 | break; |
76 | case LHCALL_SET_PTE: | 74 | case LHCALL_SET_PTE: |
77 | guest_set_pte(lg, args->arg1, args->arg2, __pte(args->arg3)); | 75 | guest_set_pte(cpu, args->arg1, args->arg2, __pte(args->arg3)); |
78 | break; | 76 | break; |
79 | case LHCALL_SET_PMD: | 77 | case LHCALL_SET_PMD: |
80 | guest_set_pmd(lg, args->arg1, args->arg2); | 78 | guest_set_pmd(cpu->lg, args->arg1, args->arg2); |
81 | break; | 79 | break; |
82 | case LHCALL_SET_CLOCKEVENT: | 80 | case LHCALL_SET_CLOCKEVENT: |
83 | guest_set_clockevent(cpu, args->arg1); | 81 | guest_set_clockevent(cpu, args->arg1); |
@@ -96,7 +94,7 @@ static void do_hcall(struct lg_cpu *cpu, struct hcall_args *args) | |||
96 | default: | 94 | default: |
97 | /* It should be an architecture-specific hypercall. */ | 95 | /* It should be an architecture-specific hypercall. */ |
98 | if (lguest_arch_do_hcall(cpu, args)) | 96 | if (lguest_arch_do_hcall(cpu, args)) |
99 | kill_guest(lg, "Bad hypercall %li\n", args->arg0); | 97 | kill_guest(cpu, "Bad hypercall %li\n", args->arg0); |
100 | } | 98 | } |
101 | } | 99 | } |
102 | /*:*/ | 100 | /*:*/ |
@@ -112,10 +110,9 @@ static void do_async_hcalls(struct lg_cpu *cpu) | |||
112 | { | 110 | { |
113 | unsigned int i; | 111 | unsigned int i; |
114 | u8 st[LHCALL_RING_SIZE]; | 112 | u8 st[LHCALL_RING_SIZE]; |
115 | struct lguest *lg = cpu->lg; | ||
116 | 113 | ||
117 | /* For simplicity, we copy the entire call status array in at once. */ | 114 | /* For simplicity, we copy the entire call status array in at once. */ |
118 | if (copy_from_user(&st, &lg->lguest_data->hcall_status, sizeof(st))) | 115 | if (copy_from_user(&st, &cpu->lg->lguest_data->hcall_status, sizeof(st))) |
119 | return; | 116 | return; |
120 | 117 | ||
121 | /* We process "struct lguest_data"s hcalls[] ring once. */ | 118 | /* We process "struct lguest_data"s hcalls[] ring once. */ |
@@ -137,9 +134,9 @@ static void do_async_hcalls(struct lg_cpu *cpu) | |||
137 | 134 | ||
138 | /* Copy the hypercall arguments into a local copy of | 135 | /* Copy the hypercall arguments into a local copy of |
139 | * the hcall_args struct. */ | 136 | * the hcall_args struct. */ |
140 | if (copy_from_user(&args, &lg->lguest_data->hcalls[n], | 137 | if (copy_from_user(&args, &cpu->lg->lguest_data->hcalls[n], |
141 | sizeof(struct hcall_args))) { | 138 | sizeof(struct hcall_args))) { |
142 | kill_guest(lg, "Fetching async hypercalls"); | 139 | kill_guest(cpu, "Fetching async hypercalls"); |
143 | break; | 140 | break; |
144 | } | 141 | } |
145 | 142 | ||
@@ -147,8 +144,8 @@ static void do_async_hcalls(struct lg_cpu *cpu) | |||
147 | do_hcall(cpu, &args); | 144 | do_hcall(cpu, &args); |
148 | 145 | ||
149 | /* Mark the hypercall done. */ | 146 | /* Mark the hypercall done. */ |
150 | if (put_user(0xFF, &lg->lguest_data->hcall_status[n])) { | 147 | if (put_user(0xFF, &cpu->lg->lguest_data->hcall_status[n])) { |
151 | kill_guest(lg, "Writing result for async hypercall"); | 148 | kill_guest(cpu, "Writing result for async hypercall"); |
152 | break; | 149 | break; |
153 | } | 150 | } |
154 | 151 | ||
@@ -163,29 +160,28 @@ static void do_async_hcalls(struct lg_cpu *cpu) | |||
163 | * Guest makes a hypercall, we end up here to set things up: */ | 160 | * Guest makes a hypercall, we end up here to set things up: */ |
164 | static void initialize(struct lg_cpu *cpu) | 161 | static void initialize(struct lg_cpu *cpu) |
165 | { | 162 | { |
166 | struct lguest *lg = cpu->lg; | ||
167 | /* You can't do anything until you're initialized. The Guest knows the | 163 | /* You can't do anything until you're initialized. The Guest knows the |
168 | * rules, so we're unforgiving here. */ | 164 | * rules, so we're unforgiving here. */ |
169 | if (cpu->hcall->arg0 != LHCALL_LGUEST_INIT) { | 165 | if (cpu->hcall->arg0 != LHCALL_LGUEST_INIT) { |
170 | kill_guest(lg, "hypercall %li before INIT", cpu->hcall->arg0); | 166 | kill_guest(cpu, "hypercall %li before INIT", cpu->hcall->arg0); |
171 | return; | 167 | return; |
172 | } | 168 | } |
173 | 169 | ||
174 | if (lguest_arch_init_hypercalls(cpu)) | 170 | if (lguest_arch_init_hypercalls(cpu)) |
175 | kill_guest(lg, "bad guest page %p", lg->lguest_data); | 171 | kill_guest(cpu, "bad guest page %p", cpu->lg->lguest_data); |
176 | 172 | ||
177 | /* The Guest tells us where we're not to deliver interrupts by putting | 173 | /* The Guest tells us where we're not to deliver interrupts by putting |
178 | * the range of addresses into "struct lguest_data". */ | 174 | * the range of addresses into "struct lguest_data". */ |
179 | if (get_user(lg->noirq_start, &lg->lguest_data->noirq_start) | 175 | if (get_user(cpu->lg->noirq_start, &cpu->lg->lguest_data->noirq_start) |
180 | || get_user(lg->noirq_end, &lg->lguest_data->noirq_end)) | 176 | || get_user(cpu->lg->noirq_end, &cpu->lg->lguest_data->noirq_end)) |
181 | kill_guest(lg, "bad guest page %p", lg->lguest_data); | 177 | kill_guest(cpu, "bad guest page %p", cpu->lg->lguest_data); |
182 | 178 | ||
183 | /* We write the current time into the Guest's data page once so it can | 179 | /* We write the current time into the Guest's data page once so it can |
184 | * set its clock. */ | 180 | * set its clock. */ |
185 | write_timestamp(lg); | 181 | write_timestamp(cpu); |
186 | 182 | ||
187 | /* page_tables.c will also do some setup. */ | 183 | /* page_tables.c will also do some setup. */ |
188 | page_table_guest_data_init(lg); | 184 | page_table_guest_data_init(cpu); |
189 | 185 | ||
190 | /* This is the one case where the above accesses might have been the | 186 | /* This is the one case where the above accesses might have been the |
191 | * first write to a Guest page. This may have caused a copy-on-write | 187 | * first write to a Guest page. This may have caused a copy-on-write |
@@ -237,10 +233,11 @@ void do_hypercalls(struct lg_cpu *cpu) | |||
237 | 233 | ||
238 | /* This routine supplies the Guest with time: it's used for wallclock time at | 234 | /* This routine supplies the Guest with time: it's used for wallclock time at |
239 | * initial boot and as a rough time source if the TSC isn't available. */ | 235 | * initial boot and as a rough time source if the TSC isn't available. */ |
240 | void write_timestamp(struct lguest *lg) | 236 | void write_timestamp(struct lg_cpu *cpu) |
241 | { | 237 | { |
242 | struct timespec now; | 238 | struct timespec now; |
243 | ktime_get_real_ts(&now); | 239 | ktime_get_real_ts(&now); |
244 | if (copy_to_user(&lg->lguest_data->time, &now, sizeof(struct timespec))) | 240 | if (copy_to_user(&cpu->lg->lguest_data->time, |
245 | kill_guest(lg, "Writing timestamp"); | 241 | &now, sizeof(struct timespec))) |
242 | kill_guest(cpu, "Writing timestamp"); | ||
246 | } | 243 | } |
diff --git a/drivers/lguest/interrupts_and_traps.c b/drivers/lguest/interrupts_and_traps.c index 9ac7455ec7fb..32e97c1858e5 100644 --- a/drivers/lguest/interrupts_and_traps.c +++ b/drivers/lguest/interrupts_and_traps.c | |||
@@ -41,11 +41,11 @@ static int idt_present(u32 lo, u32 hi) | |||
41 | 41 | ||
42 | /* We need a helper to "push" a value onto the Guest's stack, since that's a | 42 | /* We need a helper to "push" a value onto the Guest's stack, since that's a |
43 | * big part of what delivering an interrupt does. */ | 43 | * big part of what delivering an interrupt does. */ |
44 | static void push_guest_stack(struct lguest *lg, unsigned long *gstack, u32 val) | 44 | static void push_guest_stack(struct lg_cpu *cpu, unsigned long *gstack, u32 val) |
45 | { | 45 | { |
46 | /* Stack grows upwards: move stack then write value. */ | 46 | /* Stack grows upwards: move stack then write value. */ |
47 | *gstack -= 4; | 47 | *gstack -= 4; |
48 | lgwrite(lg, *gstack, u32, val); | 48 | lgwrite(cpu, *gstack, u32, val); |
49 | } | 49 | } |
50 | 50 | ||
51 | /*H:210 The set_guest_interrupt() routine actually delivers the interrupt or | 51 | /*H:210 The set_guest_interrupt() routine actually delivers the interrupt or |
@@ -65,7 +65,6 @@ static void set_guest_interrupt(struct lg_cpu *cpu, u32 lo, u32 hi, int has_err) | |||
65 | unsigned long gstack, origstack; | 65 | unsigned long gstack, origstack; |
66 | u32 eflags, ss, irq_enable; | 66 | u32 eflags, ss, irq_enable; |
67 | unsigned long virtstack; | 67 | unsigned long virtstack; |
68 | struct lguest *lg = cpu->lg; | ||
69 | 68 | ||
70 | /* There are two cases for interrupts: one where the Guest is already | 69 | /* There are two cases for interrupts: one where the Guest is already |
71 | * in the kernel, and a more complex one where the Guest is in | 70 | * in the kernel, and a more complex one where the Guest is in |
@@ -81,8 +80,8 @@ static void set_guest_interrupt(struct lg_cpu *cpu, u32 lo, u32 hi, int has_err) | |||
81 | * stack: when the Guest does an "iret" back from the interrupt | 80 | * stack: when the Guest does an "iret" back from the interrupt |
82 | * handler the CPU will notice they're dropping privilege | 81 | * handler the CPU will notice they're dropping privilege |
83 | * levels and expect these here. */ | 82 | * levels and expect these here. */ |
84 | push_guest_stack(lg, &gstack, cpu->regs->ss); | 83 | push_guest_stack(cpu, &gstack, cpu->regs->ss); |
85 | push_guest_stack(lg, &gstack, cpu->regs->esp); | 84 | push_guest_stack(cpu, &gstack, cpu->regs->esp); |
86 | } else { | 85 | } else { |
87 | /* We're staying on the same Guest (kernel) stack. */ | 86 | /* We're staying on the same Guest (kernel) stack. */ |
88 | virtstack = cpu->regs->esp; | 87 | virtstack = cpu->regs->esp; |
@@ -96,20 +95,20 @@ static void set_guest_interrupt(struct lg_cpu *cpu, u32 lo, u32 hi, int has_err) | |||
96 | * Guest's "irq_enabled" field into the eflags word: we saw the Guest | 95 | * Guest's "irq_enabled" field into the eflags word: we saw the Guest |
97 | * copy it back in "lguest_iret". */ | 96 | * copy it back in "lguest_iret". */ |
98 | eflags = cpu->regs->eflags; | 97 | eflags = cpu->regs->eflags; |
99 | if (get_user(irq_enable, &lg->lguest_data->irq_enabled) == 0 | 98 | if (get_user(irq_enable, &cpu->lg->lguest_data->irq_enabled) == 0 |
100 | && !(irq_enable & X86_EFLAGS_IF)) | 99 | && !(irq_enable & X86_EFLAGS_IF)) |
101 | eflags &= ~X86_EFLAGS_IF; | 100 | eflags &= ~X86_EFLAGS_IF; |
102 | 101 | ||
103 | /* An interrupt is expected to push three things on the stack: the old | 102 | /* An interrupt is expected to push three things on the stack: the old |
104 | * "eflags" word, the old code segment, and the old instruction | 103 | * "eflags" word, the old code segment, and the old instruction |
105 | * pointer. */ | 104 | * pointer. */ |
106 | push_guest_stack(lg, &gstack, eflags); | 105 | push_guest_stack(cpu, &gstack, eflags); |
107 | push_guest_stack(lg, &gstack, cpu->regs->cs); | 106 | push_guest_stack(cpu, &gstack, cpu->regs->cs); |
108 | push_guest_stack(lg, &gstack, cpu->regs->eip); | 107 | push_guest_stack(cpu, &gstack, cpu->regs->eip); |
109 | 108 | ||
110 | /* For the six traps which supply an error code, we push that, too. */ | 109 | /* For the six traps which supply an error code, we push that, too. */ |
111 | if (has_err) | 110 | if (has_err) |
112 | push_guest_stack(lg, &gstack, cpu->regs->errcode); | 111 | push_guest_stack(cpu, &gstack, cpu->regs->errcode); |
113 | 112 | ||
114 | /* Now we've pushed all the old state, we change the stack, the code | 113 | /* Now we've pushed all the old state, we change the stack, the code |
115 | * segment and the address to execute. */ | 114 | * segment and the address to execute. */ |
@@ -121,8 +120,8 @@ static void set_guest_interrupt(struct lg_cpu *cpu, u32 lo, u32 hi, int has_err) | |||
121 | /* There are two kinds of interrupt handlers: 0xE is an "interrupt | 120 | /* There are two kinds of interrupt handlers: 0xE is an "interrupt |
122 | * gate" which expects interrupts to be disabled on entry. */ | 121 | * gate" which expects interrupts to be disabled on entry. */ |
123 | if (idt_type(lo, hi) == 0xE) | 122 | if (idt_type(lo, hi) == 0xE) |
124 | if (put_user(0, &lg->lguest_data->irq_enabled)) | 123 | if (put_user(0, &cpu->lg->lguest_data->irq_enabled)) |
125 | kill_guest(lg, "Disabling interrupts"); | 124 | kill_guest(cpu, "Disabling interrupts"); |
126 | } | 125 | } |
127 | 126 | ||
128 | /*H:205 | 127 | /*H:205 |
@@ -133,17 +132,16 @@ static void set_guest_interrupt(struct lg_cpu *cpu, u32 lo, u32 hi, int has_err) | |||
133 | void maybe_do_interrupt(struct lg_cpu *cpu) | 132 | void maybe_do_interrupt(struct lg_cpu *cpu) |
134 | { | 133 | { |
135 | unsigned int irq; | 134 | unsigned int irq; |
136 | struct lguest *lg = cpu->lg; | ||
137 | DECLARE_BITMAP(blk, LGUEST_IRQS); | 135 | DECLARE_BITMAP(blk, LGUEST_IRQS); |
138 | struct desc_struct *idt; | 136 | struct desc_struct *idt; |
139 | 137 | ||
140 | /* If the Guest hasn't even initialized yet, we can do nothing. */ | 138 | /* If the Guest hasn't even initialized yet, we can do nothing. */ |
141 | if (!lg->lguest_data) | 139 | if (!cpu->lg->lguest_data) |
142 | return; | 140 | return; |
143 | 141 | ||
144 | /* Take our "irqs_pending" array and remove any interrupts the Guest | 142 | /* Take our "irqs_pending" array and remove any interrupts the Guest |
145 | * wants blocked: the result ends up in "blk". */ | 143 | * wants blocked: the result ends up in "blk". */ |
146 | if (copy_from_user(&blk, lg->lguest_data->blocked_interrupts, | 144 | if (copy_from_user(&blk, cpu->lg->lguest_data->blocked_interrupts, |
147 | sizeof(blk))) | 145 | sizeof(blk))) |
148 | return; | 146 | return; |
149 | 147 | ||
@@ -157,19 +155,20 @@ void maybe_do_interrupt(struct lg_cpu *cpu) | |||
157 | 155 | ||
158 | /* They may be in the middle of an iret, where they asked us never to | 156 | /* They may be in the middle of an iret, where they asked us never to |
159 | * deliver interrupts. */ | 157 | * deliver interrupts. */ |
160 | if (cpu->regs->eip >= lg->noirq_start && cpu->regs->eip < lg->noirq_end) | 158 | if (cpu->regs->eip >= cpu->lg->noirq_start && |
159 | (cpu->regs->eip < cpu->lg->noirq_end)) | ||
161 | return; | 160 | return; |
162 | 161 | ||
163 | /* If they're halted, interrupts restart them. */ | 162 | /* If they're halted, interrupts restart them. */ |
164 | if (cpu->halted) { | 163 | if (cpu->halted) { |
165 | /* Re-enable interrupts. */ | 164 | /* Re-enable interrupts. */ |
166 | if (put_user(X86_EFLAGS_IF, &lg->lguest_data->irq_enabled)) | 165 | if (put_user(X86_EFLAGS_IF, &cpu->lg->lguest_data->irq_enabled)) |
167 | kill_guest(lg, "Re-enabling interrupts"); | 166 | kill_guest(cpu, "Re-enabling interrupts"); |
168 | cpu->halted = 0; | 167 | cpu->halted = 0; |
169 | } else { | 168 | } else { |
170 | /* Otherwise we check if they have interrupts disabled. */ | 169 | /* Otherwise we check if they have interrupts disabled. */ |
171 | u32 irq_enabled; | 170 | u32 irq_enabled; |
172 | if (get_user(irq_enabled, &lg->lguest_data->irq_enabled)) | 171 | if (get_user(irq_enabled, &cpu->lg->lguest_data->irq_enabled)) |
173 | irq_enabled = 0; | 172 | irq_enabled = 0; |
174 | if (!irq_enabled) | 173 | if (!irq_enabled) |
175 | return; | 174 | return; |
@@ -194,7 +193,7 @@ void maybe_do_interrupt(struct lg_cpu *cpu) | |||
194 | * did this more often, but it can actually be quite slow: doing it | 193 | * did this more often, but it can actually be quite slow: doing it |
195 | * here is a compromise which means at least it gets updated every | 194 | * here is a compromise which means at least it gets updated every |
196 | * timer interrupt. */ | 195 | * timer interrupt. */ |
197 | write_timestamp(lg); | 196 | write_timestamp(cpu); |
198 | } | 197 | } |
199 | /*:*/ | 198 | /*:*/ |
200 | 199 | ||
@@ -315,10 +314,9 @@ void pin_stack_pages(struct lg_cpu *cpu) | |||
315 | { | 314 | { |
316 | unsigned int i; | 315 | unsigned int i; |
317 | 316 | ||
318 | struct lguest *lg = cpu->lg; | ||
319 | /* Depending on the CONFIG_4KSTACKS option, the Guest can have one or | 317 | /* Depending on the CONFIG_4KSTACKS option, the Guest can have one or |
320 | * two pages of stack space. */ | 318 | * two pages of stack space. */ |
321 | for (i = 0; i < lg->stack_pages; i++) | 319 | for (i = 0; i < cpu->lg->stack_pages; i++) |
322 | /* The stack grows *upwards*, so the address we're given is the | 320 | /* The stack grows *upwards*, so the address we're given is the |
323 | * start of the page after the kernel stack. Subtract one to | 321 | * start of the page after the kernel stack. Subtract one to |
324 | * get back onto the first stack page, and keep subtracting to | 322 | * get back onto the first stack page, and keep subtracting to |
@@ -339,10 +337,10 @@ void guest_set_stack(struct lg_cpu *cpu, u32 seg, u32 esp, unsigned int pages) | |||
339 | /* You are not allowed have a stack segment with privilege level 0: bad | 337 | /* You are not allowed have a stack segment with privilege level 0: bad |
340 | * Guest! */ | 338 | * Guest! */ |
341 | if ((seg & 0x3) != GUEST_PL) | 339 | if ((seg & 0x3) != GUEST_PL) |
342 | kill_guest(cpu->lg, "bad stack segment %i", seg); | 340 | kill_guest(cpu, "bad stack segment %i", seg); |
343 | /* We only expect one or two stack pages. */ | 341 | /* We only expect one or two stack pages. */ |
344 | if (pages > 2) | 342 | if (pages > 2) |
345 | kill_guest(cpu->lg, "bad stack pages %u", pages); | 343 | kill_guest(cpu, "bad stack pages %u", pages); |
346 | /* Save where the stack is, and how many pages */ | 344 | /* Save where the stack is, and how many pages */ |
347 | cpu->ss1 = seg; | 345 | cpu->ss1 = seg; |
348 | cpu->esp1 = esp; | 346 | cpu->esp1 = esp; |
@@ -356,7 +354,7 @@ void guest_set_stack(struct lg_cpu *cpu, u32 seg, u32 esp, unsigned int pages) | |||
356 | 354 | ||
357 | /*H:235 This is the routine which actually checks the Guest's IDT entry and | 355 | /*H:235 This is the routine which actually checks the Guest's IDT entry and |
358 | * transfers it into the entry in "struct lguest": */ | 356 | * transfers it into the entry in "struct lguest": */ |
359 | static void set_trap(struct lguest *lg, struct desc_struct *trap, | 357 | static void set_trap(struct lg_cpu *cpu, struct desc_struct *trap, |
360 | unsigned int num, u32 lo, u32 hi) | 358 | unsigned int num, u32 lo, u32 hi) |
361 | { | 359 | { |
362 | u8 type = idt_type(lo, hi); | 360 | u8 type = idt_type(lo, hi); |
@@ -369,7 +367,7 @@ static void set_trap(struct lguest *lg, struct desc_struct *trap, | |||
369 | 367 | ||
370 | /* We only support interrupt and trap gates. */ | 368 | /* We only support interrupt and trap gates. */ |
371 | if (type != 0xE && type != 0xF) | 369 | if (type != 0xE && type != 0xF) |
372 | kill_guest(lg, "bad IDT type %i", type); | 370 | kill_guest(cpu, "bad IDT type %i", type); |
373 | 371 | ||
374 | /* We only copy the handler address, present bit, privilege level and | 372 | /* We only copy the handler address, present bit, privilege level and |
375 | * type. The privilege level controls where the trap can be triggered | 373 | * type. The privilege level controls where the trap can be triggered |
@@ -399,9 +397,9 @@ void load_guest_idt_entry(struct lg_cpu *cpu, unsigned int num, u32 lo, u32 hi) | |||
399 | 397 | ||
400 | /* Check that the Guest doesn't try to step outside the bounds. */ | 398 | /* Check that the Guest doesn't try to step outside the bounds. */ |
401 | if (num >= ARRAY_SIZE(cpu->arch.idt)) | 399 | if (num >= ARRAY_SIZE(cpu->arch.idt)) |
402 | kill_guest(cpu->lg, "Setting idt entry %u", num); | 400 | kill_guest(cpu, "Setting idt entry %u", num); |
403 | else | 401 | else |
404 | set_trap(cpu->lg, &cpu->arch.idt[num], num, lo, hi); | 402 | set_trap(cpu, &cpu->arch.idt[num], num, lo, hi); |
405 | } | 403 | } |
406 | 404 | ||
407 | /* The default entry for each interrupt points into the Switcher routines which | 405 | /* The default entry for each interrupt points into the Switcher routines which |
diff --git a/drivers/lguest/lg.h b/drivers/lguest/lg.h index 0d6f6435d72c..b75ce3b17afe 100644 --- a/drivers/lguest/lg.h +++ b/drivers/lguest/lg.h | |||
@@ -111,22 +111,22 @@ extern struct mutex lguest_lock; | |||
111 | /* core.c: */ | 111 | /* core.c: */ |
112 | int lguest_address_ok(const struct lguest *lg, | 112 | int lguest_address_ok(const struct lguest *lg, |
113 | unsigned long addr, unsigned long len); | 113 | unsigned long addr, unsigned long len); |
114 | void __lgread(struct lguest *, void *, unsigned long, unsigned); | 114 | void __lgread(struct lg_cpu *, void *, unsigned long, unsigned); |
115 | void __lgwrite(struct lguest *, unsigned long, const void *, unsigned); | 115 | void __lgwrite(struct lg_cpu *, unsigned long, const void *, unsigned); |
116 | 116 | ||
117 | /*H:035 Using memory-copy operations like that is usually inconvient, so we | 117 | /*H:035 Using memory-copy operations like that is usually inconvient, so we |
118 | * have the following helper macros which read and write a specific type (often | 118 | * have the following helper macros which read and write a specific type (often |
119 | * an unsigned long). | 119 | * an unsigned long). |
120 | * | 120 | * |
121 | * This reads into a variable of the given type then returns that. */ | 121 | * This reads into a variable of the given type then returns that. */ |
122 | #define lgread(lg, addr, type) \ | 122 | #define lgread(cpu, addr, type) \ |
123 | ({ type _v; __lgread((lg), &_v, (addr), sizeof(_v)); _v; }) | 123 | ({ type _v; __lgread((cpu), &_v, (addr), sizeof(_v)); _v; }) |
124 | 124 | ||
125 | /* This checks that the variable is of the given type, then writes it out. */ | 125 | /* This checks that the variable is of the given type, then writes it out. */ |
126 | #define lgwrite(lg, addr, type, val) \ | 126 | #define lgwrite(cpu, addr, type, val) \ |
127 | do { \ | 127 | do { \ |
128 | typecheck(type, val); \ | 128 | typecheck(type, val); \ |
129 | __lgwrite((lg), (addr), &(val), sizeof(val)); \ | 129 | __lgwrite((cpu), (addr), &(val), sizeof(val)); \ |
130 | } while(0) | 130 | } while(0) |
131 | /* (end of memory access helper routines) :*/ | 131 | /* (end of memory access helper routines) :*/ |
132 | 132 | ||
@@ -171,13 +171,13 @@ void guest_new_pagetable(struct lg_cpu *cpu, unsigned long pgtable); | |||
171 | void guest_set_pmd(struct lguest *lg, unsigned long gpgdir, u32 i); | 171 | void guest_set_pmd(struct lguest *lg, unsigned long gpgdir, u32 i); |
172 | void guest_pagetable_clear_all(struct lg_cpu *cpu); | 172 | void guest_pagetable_clear_all(struct lg_cpu *cpu); |
173 | void guest_pagetable_flush_user(struct lg_cpu *cpu); | 173 | void guest_pagetable_flush_user(struct lg_cpu *cpu); |
174 | void guest_set_pte(struct lguest *lg, unsigned long gpgdir, | 174 | void guest_set_pte(struct lg_cpu *cpu, unsigned long gpgdir, |
175 | unsigned long vaddr, pte_t val); | 175 | unsigned long vaddr, pte_t val); |
176 | void map_switcher_in_guest(struct lg_cpu *cpu, struct lguest_pages *pages); | 176 | void map_switcher_in_guest(struct lg_cpu *cpu, struct lguest_pages *pages); |
177 | int demand_page(struct lg_cpu *cpu, unsigned long cr2, int errcode); | 177 | int demand_page(struct lg_cpu *cpu, unsigned long cr2, int errcode); |
178 | void pin_page(struct lg_cpu *cpu, unsigned long vaddr); | 178 | void pin_page(struct lg_cpu *cpu, unsigned long vaddr); |
179 | unsigned long guest_pa(struct lg_cpu *cpu, unsigned long vaddr); | 179 | unsigned long guest_pa(struct lg_cpu *cpu, unsigned long vaddr); |
180 | void page_table_guest_data_init(struct lguest *lg); | 180 | void page_table_guest_data_init(struct lg_cpu *cpu); |
181 | 181 | ||
182 | /* <arch>/core.c: */ | 182 | /* <arch>/core.c: */ |
183 | void lguest_arch_host_init(void); | 183 | void lguest_arch_host_init(void); |
@@ -197,7 +197,7 @@ void lguest_device_remove(void); | |||
197 | 197 | ||
198 | /* hypercalls.c: */ | 198 | /* hypercalls.c: */ |
199 | void do_hypercalls(struct lg_cpu *cpu); | 199 | void do_hypercalls(struct lg_cpu *cpu); |
200 | void write_timestamp(struct lguest *lg); | 200 | void write_timestamp(struct lg_cpu *cpu); |
201 | 201 | ||
202 | /*L:035 | 202 | /*L:035 |
203 | * Let's step aside for the moment, to study one important routine that's used | 203 | * Let's step aside for the moment, to study one important routine that's used |
@@ -223,12 +223,12 @@ void write_timestamp(struct lguest *lg); | |||
223 | * Like any macro which uses an "if", it is safely wrapped in a run-once "do { | 223 | * Like any macro which uses an "if", it is safely wrapped in a run-once "do { |
224 | * } while(0)". | 224 | * } while(0)". |
225 | */ | 225 | */ |
226 | #define kill_guest(lg, fmt...) \ | 226 | #define kill_guest(cpu, fmt...) \ |
227 | do { \ | 227 | do { \ |
228 | if (!(lg)->dead) { \ | 228 | if (!(cpu)->lg->dead) { \ |
229 | (lg)->dead = kasprintf(GFP_ATOMIC, fmt); \ | 229 | (cpu)->lg->dead = kasprintf(GFP_ATOMIC, fmt); \ |
230 | if (!(lg)->dead) \ | 230 | if (!(cpu)->lg->dead) \ |
231 | (lg)->dead = ERR_PTR(-ENOMEM); \ | 231 | (cpu)->lg->dead = ERR_PTR(-ENOMEM); \ |
232 | } \ | 232 | } \ |
233 | } while(0) | 233 | } while(0) |
234 | /* (End of aside) :*/ | 234 | /* (End of aside) :*/ |
diff --git a/drivers/lguest/page_tables.c b/drivers/lguest/page_tables.c index c9acafcab2aa..983e9020cef8 100644 --- a/drivers/lguest/page_tables.c +++ b/drivers/lguest/page_tables.c | |||
@@ -68,17 +68,17 @@ static DEFINE_PER_CPU(pte_t *, switcher_pte_pages); | |||
68 | * page directory entry (PGD) for that address. Since we keep track of several | 68 | * page directory entry (PGD) for that address. Since we keep track of several |
69 | * page tables, the "i" argument tells us which one we're interested in (it's | 69 | * page tables, the "i" argument tells us which one we're interested in (it's |
70 | * usually the current one). */ | 70 | * usually the current one). */ |
71 | static pgd_t *spgd_addr(struct lguest *lg, u32 i, unsigned long vaddr) | 71 | static pgd_t *spgd_addr(struct lg_cpu *cpu, u32 i, unsigned long vaddr) |
72 | { | 72 | { |
73 | unsigned int index = pgd_index(vaddr); | 73 | unsigned int index = pgd_index(vaddr); |
74 | 74 | ||
75 | /* We kill any Guest trying to touch the Switcher addresses. */ | 75 | /* We kill any Guest trying to touch the Switcher addresses. */ |
76 | if (index >= SWITCHER_PGD_INDEX) { | 76 | if (index >= SWITCHER_PGD_INDEX) { |
77 | kill_guest(lg, "attempt to access switcher pages"); | 77 | kill_guest(cpu, "attempt to access switcher pages"); |
78 | index = 0; | 78 | index = 0; |
79 | } | 79 | } |
80 | /* Return a pointer index'th pgd entry for the i'th page table. */ | 80 | /* Return a pointer index'th pgd entry for the i'th page table. */ |
81 | return &lg->pgdirs[i].pgdir[index]; | 81 | return &cpu->lg->pgdirs[i].pgdir[index]; |
82 | } | 82 | } |
83 | 83 | ||
84 | /* This routine then takes the page directory entry returned above, which | 84 | /* This routine then takes the page directory entry returned above, which |
@@ -137,7 +137,7 @@ static unsigned long get_pfn(unsigned long virtpfn, int write) | |||
137 | * entry can be a little tricky. The flags are (almost) the same, but the | 137 | * entry can be a little tricky. The flags are (almost) the same, but the |
138 | * Guest PTE contains a virtual page number: the CPU needs the real page | 138 | * Guest PTE contains a virtual page number: the CPU needs the real page |
139 | * number. */ | 139 | * number. */ |
140 | static pte_t gpte_to_spte(struct lguest *lg, pte_t gpte, int write) | 140 | static pte_t gpte_to_spte(struct lg_cpu *cpu, pte_t gpte, int write) |
141 | { | 141 | { |
142 | unsigned long pfn, base, flags; | 142 | unsigned long pfn, base, flags; |
143 | 143 | ||
@@ -148,7 +148,7 @@ static pte_t gpte_to_spte(struct lguest *lg, pte_t gpte, int write) | |||
148 | flags = (pte_flags(gpte) & ~_PAGE_GLOBAL); | 148 | flags = (pte_flags(gpte) & ~_PAGE_GLOBAL); |
149 | 149 | ||
150 | /* The Guest's pages are offset inside the Launcher. */ | 150 | /* The Guest's pages are offset inside the Launcher. */ |
151 | base = (unsigned long)lg->mem_base / PAGE_SIZE; | 151 | base = (unsigned long)cpu->lg->mem_base / PAGE_SIZE; |
152 | 152 | ||
153 | /* We need a temporary "unsigned long" variable to hold the answer from | 153 | /* We need a temporary "unsigned long" variable to hold the answer from |
154 | * get_pfn(), because it returns 0xFFFFFFFF on failure, which wouldn't | 154 | * get_pfn(), because it returns 0xFFFFFFFF on failure, which wouldn't |
@@ -156,7 +156,7 @@ static pte_t gpte_to_spte(struct lguest *lg, pte_t gpte, int write) | |||
156 | * page, given the virtual number. */ | 156 | * page, given the virtual number. */ |
157 | pfn = get_pfn(base + pte_pfn(gpte), write); | 157 | pfn = get_pfn(base + pte_pfn(gpte), write); |
158 | if (pfn == -1UL) { | 158 | if (pfn == -1UL) { |
159 | kill_guest(lg, "failed to get page %lu", pte_pfn(gpte)); | 159 | kill_guest(cpu, "failed to get page %lu", pte_pfn(gpte)); |
160 | /* When we destroy the Guest, we'll go through the shadow page | 160 | /* When we destroy the Guest, we'll go through the shadow page |
161 | * tables and release_pte() them. Make sure we don't think | 161 | * tables and release_pte() them. Make sure we don't think |
162 | * this one is valid! */ | 162 | * this one is valid! */ |
@@ -176,17 +176,18 @@ static void release_pte(pte_t pte) | |||
176 | } | 176 | } |
177 | /*:*/ | 177 | /*:*/ |
178 | 178 | ||
179 | static void check_gpte(struct lguest *lg, pte_t gpte) | 179 | static void check_gpte(struct lg_cpu *cpu, pte_t gpte) |
180 | { | 180 | { |
181 | if ((pte_flags(gpte) & (_PAGE_PWT|_PAGE_PSE)) | 181 | if ((pte_flags(gpte) & (_PAGE_PWT|_PAGE_PSE)) |
182 | || pte_pfn(gpte) >= lg->pfn_limit) | 182 | || pte_pfn(gpte) >= cpu->lg->pfn_limit) |
183 | kill_guest(lg, "bad page table entry"); | 183 | kill_guest(cpu, "bad page table entry"); |
184 | } | 184 | } |
185 | 185 | ||
186 | static void check_gpgd(struct lguest *lg, pgd_t gpgd) | 186 | static void check_gpgd(struct lg_cpu *cpu, pgd_t gpgd) |
187 | { | 187 | { |
188 | if ((pgd_flags(gpgd) & ~_PAGE_TABLE) || pgd_pfn(gpgd) >= lg->pfn_limit) | 188 | if ((pgd_flags(gpgd) & ~_PAGE_TABLE) || |
189 | kill_guest(lg, "bad page directory entry"); | 189 | (pgd_pfn(gpgd) >= cpu->lg->pfn_limit)) |
190 | kill_guest(cpu, "bad page directory entry"); | ||
190 | } | 191 | } |
191 | 192 | ||
192 | /*H:330 | 193 | /*H:330 |
@@ -206,27 +207,26 @@ int demand_page(struct lg_cpu *cpu, unsigned long vaddr, int errcode) | |||
206 | unsigned long gpte_ptr; | 207 | unsigned long gpte_ptr; |
207 | pte_t gpte; | 208 | pte_t gpte; |
208 | pte_t *spte; | 209 | pte_t *spte; |
209 | struct lguest *lg = cpu->lg; | ||
210 | 210 | ||
211 | /* First step: get the top-level Guest page table entry. */ | 211 | /* First step: get the top-level Guest page table entry. */ |
212 | gpgd = lgread(lg, gpgd_addr(cpu, vaddr), pgd_t); | 212 | gpgd = lgread(cpu, gpgd_addr(cpu, vaddr), pgd_t); |
213 | /* Toplevel not present? We can't map it in. */ | 213 | /* Toplevel not present? We can't map it in. */ |
214 | if (!(pgd_flags(gpgd) & _PAGE_PRESENT)) | 214 | if (!(pgd_flags(gpgd) & _PAGE_PRESENT)) |
215 | return 0; | 215 | return 0; |
216 | 216 | ||
217 | /* Now look at the matching shadow entry. */ | 217 | /* Now look at the matching shadow entry. */ |
218 | spgd = spgd_addr(lg, cpu->cpu_pgd, vaddr); | 218 | spgd = spgd_addr(cpu, cpu->cpu_pgd, vaddr); |
219 | if (!(pgd_flags(*spgd) & _PAGE_PRESENT)) { | 219 | if (!(pgd_flags(*spgd) & _PAGE_PRESENT)) { |
220 | /* No shadow entry: allocate a new shadow PTE page. */ | 220 | /* No shadow entry: allocate a new shadow PTE page. */ |
221 | unsigned long ptepage = get_zeroed_page(GFP_KERNEL); | 221 | unsigned long ptepage = get_zeroed_page(GFP_KERNEL); |
222 | /* This is not really the Guest's fault, but killing it is | 222 | /* This is not really the Guest's fault, but killing it is |
223 | * simple for this corner case. */ | 223 | * simple for this corner case. */ |
224 | if (!ptepage) { | 224 | if (!ptepage) { |
225 | kill_guest(lg, "out of memory allocating pte page"); | 225 | kill_guest(cpu, "out of memory allocating pte page"); |
226 | return 0; | 226 | return 0; |
227 | } | 227 | } |
228 | /* We check that the Guest pgd is OK. */ | 228 | /* We check that the Guest pgd is OK. */ |
229 | check_gpgd(lg, gpgd); | 229 | check_gpgd(cpu, gpgd); |
230 | /* And we copy the flags to the shadow PGD entry. The page | 230 | /* And we copy the flags to the shadow PGD entry. The page |
231 | * number in the shadow PGD is the page we just allocated. */ | 231 | * number in the shadow PGD is the page we just allocated. */ |
232 | *spgd = __pgd(__pa(ptepage) | pgd_flags(gpgd)); | 232 | *spgd = __pgd(__pa(ptepage) | pgd_flags(gpgd)); |
@@ -235,7 +235,7 @@ int demand_page(struct lg_cpu *cpu, unsigned long vaddr, int errcode) | |||
235 | /* OK, now we look at the lower level in the Guest page table: keep its | 235 | /* OK, now we look at the lower level in the Guest page table: keep its |
236 | * address, because we might update it later. */ | 236 | * address, because we might update it later. */ |
237 | gpte_ptr = gpte_addr(gpgd, vaddr); | 237 | gpte_ptr = gpte_addr(gpgd, vaddr); |
238 | gpte = lgread(lg, gpte_ptr, pte_t); | 238 | gpte = lgread(cpu, gpte_ptr, pte_t); |
239 | 239 | ||
240 | /* If this page isn't in the Guest page tables, we can't page it in. */ | 240 | /* If this page isn't in the Guest page tables, we can't page it in. */ |
241 | if (!(pte_flags(gpte) & _PAGE_PRESENT)) | 241 | if (!(pte_flags(gpte) & _PAGE_PRESENT)) |
@@ -252,7 +252,7 @@ int demand_page(struct lg_cpu *cpu, unsigned long vaddr, int errcode) | |||
252 | 252 | ||
253 | /* Check that the Guest PTE flags are OK, and the page number is below | 253 | /* Check that the Guest PTE flags are OK, and the page number is below |
254 | * the pfn_limit (ie. not mapping the Launcher binary). */ | 254 | * the pfn_limit (ie. not mapping the Launcher binary). */ |
255 | check_gpte(lg, gpte); | 255 | check_gpte(cpu, gpte); |
256 | 256 | ||
257 | /* Add the _PAGE_ACCESSED and (for a write) _PAGE_DIRTY flag */ | 257 | /* Add the _PAGE_ACCESSED and (for a write) _PAGE_DIRTY flag */ |
258 | gpte = pte_mkyoung(gpte); | 258 | gpte = pte_mkyoung(gpte); |
@@ -268,17 +268,17 @@ int demand_page(struct lg_cpu *cpu, unsigned long vaddr, int errcode) | |||
268 | /* If this is a write, we insist that the Guest page is writable (the | 268 | /* If this is a write, we insist that the Guest page is writable (the |
269 | * final arg to gpte_to_spte()). */ | 269 | * final arg to gpte_to_spte()). */ |
270 | if (pte_dirty(gpte)) | 270 | if (pte_dirty(gpte)) |
271 | *spte = gpte_to_spte(lg, gpte, 1); | 271 | *spte = gpte_to_spte(cpu, gpte, 1); |
272 | else | 272 | else |
273 | /* If this is a read, don't set the "writable" bit in the page | 273 | /* If this is a read, don't set the "writable" bit in the page |
274 | * table entry, even if the Guest says it's writable. That way | 274 | * table entry, even if the Guest says it's writable. That way |
275 | * we will come back here when a write does actually occur, so | 275 | * we will come back here when a write does actually occur, so |
276 | * we can update the Guest's _PAGE_DIRTY flag. */ | 276 | * we can update the Guest's _PAGE_DIRTY flag. */ |
277 | *spte = gpte_to_spte(lg, pte_wrprotect(gpte), 0); | 277 | *spte = gpte_to_spte(cpu, pte_wrprotect(gpte), 0); |
278 | 278 | ||
279 | /* Finally, we write the Guest PTE entry back: we've set the | 279 | /* Finally, we write the Guest PTE entry back: we've set the |
280 | * _PAGE_ACCESSED and maybe the _PAGE_DIRTY flags. */ | 280 | * _PAGE_ACCESSED and maybe the _PAGE_DIRTY flags. */ |
281 | lgwrite(lg, gpte_ptr, pte_t, gpte); | 281 | lgwrite(cpu, gpte_ptr, pte_t, gpte); |
282 | 282 | ||
283 | /* The fault is fixed, the page table is populated, the mapping | 283 | /* The fault is fixed, the page table is populated, the mapping |
284 | * manipulated, the result returned and the code complete. A small | 284 | * manipulated, the result returned and the code complete. A small |
@@ -303,7 +303,7 @@ static int page_writable(struct lg_cpu *cpu, unsigned long vaddr) | |||
303 | unsigned long flags; | 303 | unsigned long flags; |
304 | 304 | ||
305 | /* Look at the current top level entry: is it present? */ | 305 | /* Look at the current top level entry: is it present? */ |
306 | spgd = spgd_addr(cpu->lg, cpu->cpu_pgd, vaddr); | 306 | spgd = spgd_addr(cpu, cpu->cpu_pgd, vaddr); |
307 | if (!(pgd_flags(*spgd) & _PAGE_PRESENT)) | 307 | if (!(pgd_flags(*spgd) & _PAGE_PRESENT)) |
308 | return 0; | 308 | return 0; |
309 | 309 | ||
@@ -320,7 +320,7 @@ static int page_writable(struct lg_cpu *cpu, unsigned long vaddr) | |||
320 | void pin_page(struct lg_cpu *cpu, unsigned long vaddr) | 320 | void pin_page(struct lg_cpu *cpu, unsigned long vaddr) |
321 | { | 321 | { |
322 | if (!page_writable(cpu, vaddr) && !demand_page(cpu, vaddr, 2)) | 322 | if (!page_writable(cpu, vaddr) && !demand_page(cpu, vaddr, 2)) |
323 | kill_guest(cpu->lg, "bad stack page %#lx", vaddr); | 323 | kill_guest(cpu, "bad stack page %#lx", vaddr); |
324 | } | 324 | } |
325 | 325 | ||
326 | /*H:450 If we chase down the release_pgd() code, it looks like this: */ | 326 | /*H:450 If we chase down the release_pgd() code, it looks like this: */ |
@@ -372,14 +372,14 @@ unsigned long guest_pa(struct lg_cpu *cpu, unsigned long vaddr) | |||
372 | pte_t gpte; | 372 | pte_t gpte; |
373 | 373 | ||
374 | /* First step: get the top-level Guest page table entry. */ | 374 | /* First step: get the top-level Guest page table entry. */ |
375 | gpgd = lgread(cpu->lg, gpgd_addr(cpu, vaddr), pgd_t); | 375 | gpgd = lgread(cpu, gpgd_addr(cpu, vaddr), pgd_t); |
376 | /* Toplevel not present? We can't map it in. */ | 376 | /* Toplevel not present? We can't map it in. */ |
377 | if (!(pgd_flags(gpgd) & _PAGE_PRESENT)) | 377 | if (!(pgd_flags(gpgd) & _PAGE_PRESENT)) |
378 | kill_guest(cpu->lg, "Bad address %#lx", vaddr); | 378 | kill_guest(cpu, "Bad address %#lx", vaddr); |
379 | 379 | ||
380 | gpte = lgread(cpu->lg, gpte_addr(gpgd, vaddr), pte_t); | 380 | gpte = lgread(cpu, gpte_addr(gpgd, vaddr), pte_t); |
381 | if (!(pte_flags(gpte) & _PAGE_PRESENT)) | 381 | if (!(pte_flags(gpte) & _PAGE_PRESENT)) |
382 | kill_guest(cpu->lg, "Bad address %#lx", vaddr); | 382 | kill_guest(cpu, "Bad address %#lx", vaddr); |
383 | 383 | ||
384 | return pte_pfn(gpte) * PAGE_SIZE | (vaddr & ~PAGE_MASK); | 384 | return pte_pfn(gpte) * PAGE_SIZE | (vaddr & ~PAGE_MASK); |
385 | } | 385 | } |
@@ -404,16 +404,16 @@ static unsigned int new_pgdir(struct lg_cpu *cpu, | |||
404 | int *blank_pgdir) | 404 | int *blank_pgdir) |
405 | { | 405 | { |
406 | unsigned int next; | 406 | unsigned int next; |
407 | struct lguest *lg = cpu->lg; | ||
408 | 407 | ||
409 | /* We pick one entry at random to throw out. Choosing the Least | 408 | /* We pick one entry at random to throw out. Choosing the Least |
410 | * Recently Used might be better, but this is easy. */ | 409 | * Recently Used might be better, but this is easy. */ |
411 | next = random32() % ARRAY_SIZE(lg->pgdirs); | 410 | next = random32() % ARRAY_SIZE(cpu->lg->pgdirs); |
412 | /* If it's never been allocated at all before, try now. */ | 411 | /* If it's never been allocated at all before, try now. */ |
413 | if (!lg->pgdirs[next].pgdir) { | 412 | if (!cpu->lg->pgdirs[next].pgdir) { |
414 | lg->pgdirs[next].pgdir = (pgd_t *)get_zeroed_page(GFP_KERNEL); | 413 | cpu->lg->pgdirs[next].pgdir = |
414 | (pgd_t *)get_zeroed_page(GFP_KERNEL); | ||
415 | /* If the allocation fails, just keep using the one we have */ | 415 | /* If the allocation fails, just keep using the one we have */ |
416 | if (!lg->pgdirs[next].pgdir) | 416 | if (!cpu->lg->pgdirs[next].pgdir) |
417 | next = cpu->cpu_pgd; | 417 | next = cpu->cpu_pgd; |
418 | else | 418 | else |
419 | /* This is a blank page, so there are no kernel | 419 | /* This is a blank page, so there are no kernel |
@@ -421,9 +421,9 @@ static unsigned int new_pgdir(struct lg_cpu *cpu, | |||
421 | *blank_pgdir = 1; | 421 | *blank_pgdir = 1; |
422 | } | 422 | } |
423 | /* Record which Guest toplevel this shadows. */ | 423 | /* Record which Guest toplevel this shadows. */ |
424 | lg->pgdirs[next].gpgdir = gpgdir; | 424 | cpu->lg->pgdirs[next].gpgdir = gpgdir; |
425 | /* Release all the non-kernel mappings. */ | 425 | /* Release all the non-kernel mappings. */ |
426 | flush_user_mappings(lg, next); | 426 | flush_user_mappings(cpu->lg, next); |
427 | 427 | ||
428 | return next; | 428 | return next; |
429 | } | 429 | } |
@@ -436,13 +436,12 @@ static unsigned int new_pgdir(struct lg_cpu *cpu, | |||
436 | void guest_new_pagetable(struct lg_cpu *cpu, unsigned long pgtable) | 436 | void guest_new_pagetable(struct lg_cpu *cpu, unsigned long pgtable) |
437 | { | 437 | { |
438 | int newpgdir, repin = 0; | 438 | int newpgdir, repin = 0; |
439 | struct lguest *lg = cpu->lg; | ||
440 | 439 | ||
441 | /* Look to see if we have this one already. */ | 440 | /* Look to see if we have this one already. */ |
442 | newpgdir = find_pgdir(lg, pgtable); | 441 | newpgdir = find_pgdir(cpu->lg, pgtable); |
443 | /* If not, we allocate or mug an existing one: if it's a fresh one, | 442 | /* If not, we allocate or mug an existing one: if it's a fresh one, |
444 | * repin gets set to 1. */ | 443 | * repin gets set to 1. */ |
445 | if (newpgdir == ARRAY_SIZE(lg->pgdirs)) | 444 | if (newpgdir == ARRAY_SIZE(cpu->lg->pgdirs)) |
446 | newpgdir = new_pgdir(cpu, pgtable, &repin); | 445 | newpgdir = new_pgdir(cpu, pgtable, &repin); |
447 | /* Change the current pgd index to the new one. */ | 446 | /* Change the current pgd index to the new one. */ |
448 | cpu->cpu_pgd = newpgdir; | 447 | cpu->cpu_pgd = newpgdir; |
@@ -499,11 +498,11 @@ void guest_pagetable_clear_all(struct lg_cpu *cpu) | |||
499 | * _PAGE_ACCESSED then we can put a read-only PTE entry in immediately, and if | 498 | * _PAGE_ACCESSED then we can put a read-only PTE entry in immediately, and if |
500 | * they set _PAGE_DIRTY then we can put a writable PTE entry in immediately. | 499 | * they set _PAGE_DIRTY then we can put a writable PTE entry in immediately. |
501 | */ | 500 | */ |
502 | static void do_set_pte(struct lguest *lg, int idx, | 501 | static void do_set_pte(struct lg_cpu *cpu, int idx, |
503 | unsigned long vaddr, pte_t gpte) | 502 | unsigned long vaddr, pte_t gpte) |
504 | { | 503 | { |
505 | /* Look up the matching shadow page directory entry. */ | 504 | /* Look up the matching shadow page directory entry. */ |
506 | pgd_t *spgd = spgd_addr(lg, idx, vaddr); | 505 | pgd_t *spgd = spgd_addr(cpu, idx, vaddr); |
507 | 506 | ||
508 | /* If the top level isn't present, there's no entry to update. */ | 507 | /* If the top level isn't present, there's no entry to update. */ |
509 | if (pgd_flags(*spgd) & _PAGE_PRESENT) { | 508 | if (pgd_flags(*spgd) & _PAGE_PRESENT) { |
@@ -515,8 +514,8 @@ static void do_set_pte(struct lguest *lg, int idx, | |||
515 | * as well put that entry they've given us in now. This shaves | 514 | * as well put that entry they've given us in now. This shaves |
516 | * 10% off a copy-on-write micro-benchmark. */ | 515 | * 10% off a copy-on-write micro-benchmark. */ |
517 | if (pte_flags(gpte) & (_PAGE_DIRTY | _PAGE_ACCESSED)) { | 516 | if (pte_flags(gpte) & (_PAGE_DIRTY | _PAGE_ACCESSED)) { |
518 | check_gpte(lg, gpte); | 517 | check_gpte(cpu, gpte); |
519 | *spte = gpte_to_spte(lg, gpte, | 518 | *spte = gpte_to_spte(cpu, gpte, |
520 | pte_flags(gpte) & _PAGE_DIRTY); | 519 | pte_flags(gpte) & _PAGE_DIRTY); |
521 | } else | 520 | } else |
522 | /* Otherwise kill it and we can demand_page() it in | 521 | /* Otherwise kill it and we can demand_page() it in |
@@ -535,22 +534,22 @@ static void do_set_pte(struct lguest *lg, int idx, | |||
535 | * | 534 | * |
536 | * The benefit is that when we have to track a new page table, we can copy keep | 535 | * The benefit is that when we have to track a new page table, we can copy keep |
537 | * all the kernel mappings. This speeds up context switch immensely. */ | 536 | * all the kernel mappings. This speeds up context switch immensely. */ |
538 | void guest_set_pte(struct lguest *lg, | 537 | void guest_set_pte(struct lg_cpu *cpu, |
539 | unsigned long gpgdir, unsigned long vaddr, pte_t gpte) | 538 | unsigned long gpgdir, unsigned long vaddr, pte_t gpte) |
540 | { | 539 | { |
541 | /* Kernel mappings must be changed on all top levels. Slow, but | 540 | /* Kernel mappings must be changed on all top levels. Slow, but |
542 | * doesn't happen often. */ | 541 | * doesn't happen often. */ |
543 | if (vaddr >= lg->kernel_address) { | 542 | if (vaddr >= cpu->lg->kernel_address) { |
544 | unsigned int i; | 543 | unsigned int i; |
545 | for (i = 0; i < ARRAY_SIZE(lg->pgdirs); i++) | 544 | for (i = 0; i < ARRAY_SIZE(cpu->lg->pgdirs); i++) |
546 | if (lg->pgdirs[i].pgdir) | 545 | if (cpu->lg->pgdirs[i].pgdir) |
547 | do_set_pte(lg, i, vaddr, gpte); | 546 | do_set_pte(cpu, i, vaddr, gpte); |
548 | } else { | 547 | } else { |
549 | /* Is this page table one we have a shadow for? */ | 548 | /* Is this page table one we have a shadow for? */ |
550 | int pgdir = find_pgdir(lg, gpgdir); | 549 | int pgdir = find_pgdir(cpu->lg, gpgdir); |
551 | if (pgdir != ARRAY_SIZE(lg->pgdirs)) | 550 | if (pgdir != ARRAY_SIZE(cpu->lg->pgdirs)) |
552 | /* If so, do the update. */ | 551 | /* If so, do the update. */ |
553 | do_set_pte(lg, pgdir, vaddr, gpte); | 552 | do_set_pte(cpu, pgdir, vaddr, gpte); |
554 | } | 553 | } |
555 | } | 554 | } |
556 | 555 | ||
@@ -601,21 +600,23 @@ int init_guest_pagetable(struct lguest *lg, unsigned long pgtable) | |||
601 | } | 600 | } |
602 | 601 | ||
603 | /* When the Guest calls LHCALL_LGUEST_INIT we do more setup. */ | 602 | /* When the Guest calls LHCALL_LGUEST_INIT we do more setup. */ |
604 | void page_table_guest_data_init(struct lguest *lg) | 603 | void page_table_guest_data_init(struct lg_cpu *cpu) |
605 | { | 604 | { |
606 | /* We get the kernel address: above this is all kernel memory. */ | 605 | /* We get the kernel address: above this is all kernel memory. */ |
607 | if (get_user(lg->kernel_address, &lg->lguest_data->kernel_address) | 606 | if (get_user(cpu->lg->kernel_address, |
607 | &cpu->lg->lguest_data->kernel_address) | ||
608 | /* We tell the Guest that it can't use the top 4MB of virtual | 608 | /* We tell the Guest that it can't use the top 4MB of virtual |
609 | * addresses used by the Switcher. */ | 609 | * addresses used by the Switcher. */ |
610 | || put_user(4U*1024*1024, &lg->lguest_data->reserve_mem) | 610 | || put_user(4U*1024*1024, &cpu->lg->lguest_data->reserve_mem) |
611 | || put_user(lg->pgdirs[0].gpgdir, &lg->lguest_data->pgdir)) | 611 | || put_user(cpu->lg->pgdirs[0].gpgdir, &cpu->lg->lguest_data->pgdir)) |
612 | kill_guest(lg, "bad guest page %p", lg->lguest_data); | 612 | kill_guest(cpu, "bad guest page %p", cpu->lg->lguest_data); |
613 | 613 | ||
614 | /* In flush_user_mappings() we loop from 0 to | 614 | /* In flush_user_mappings() we loop from 0 to |
615 | * "pgd_index(lg->kernel_address)". This assumes it won't hit the | 615 | * "pgd_index(lg->kernel_address)". This assumes it won't hit the |
616 | * Switcher mappings, so check that now. */ | 616 | * Switcher mappings, so check that now. */ |
617 | if (pgd_index(lg->kernel_address) >= SWITCHER_PGD_INDEX) | 617 | if (pgd_index(cpu->lg->kernel_address) >= SWITCHER_PGD_INDEX) |
618 | kill_guest(lg, "bad kernel address %#lx", lg->kernel_address); | 618 | kill_guest(cpu, "bad kernel address %#lx", |
619 | cpu->lg->kernel_address); | ||
619 | } | 620 | } |
620 | 621 | ||
621 | /* When a Guest dies, our cleanup is fairly simple. */ | 622 | /* When a Guest dies, our cleanup is fairly simple. */ |
diff --git a/drivers/lguest/segments.c b/drivers/lguest/segments.c index 635f54c719ae..ec6aa3f1c36b 100644 --- a/drivers/lguest/segments.c +++ b/drivers/lguest/segments.c | |||
@@ -148,14 +148,13 @@ void copy_gdt(const struct lg_cpu *cpu, struct desc_struct *gdt) | |||
148 | * We copy it from the Guest and tweak the entries. */ | 148 | * We copy it from the Guest and tweak the entries. */ |
149 | void load_guest_gdt(struct lg_cpu *cpu, unsigned long table, u32 num) | 149 | void load_guest_gdt(struct lg_cpu *cpu, unsigned long table, u32 num) |
150 | { | 150 | { |
151 | struct lguest *lg = cpu->lg; | ||
152 | /* We assume the Guest has the same number of GDT entries as the | 151 | /* We assume the Guest has the same number of GDT entries as the |
153 | * Host, otherwise we'd have to dynamically allocate the Guest GDT. */ | 152 | * Host, otherwise we'd have to dynamically allocate the Guest GDT. */ |
154 | if (num > ARRAY_SIZE(cpu->arch.gdt)) | 153 | if (num > ARRAY_SIZE(cpu->arch.gdt)) |
155 | kill_guest(lg, "too many gdt entries %i", num); | 154 | kill_guest(cpu, "too many gdt entries %i", num); |
156 | 155 | ||
157 | /* We read the whole thing in, then fix it up. */ | 156 | /* We read the whole thing in, then fix it up. */ |
158 | __lgread(lg, cpu->arch.gdt, table, num * sizeof(cpu->arch.gdt[0])); | 157 | __lgread(cpu, cpu->arch.gdt, table, num * sizeof(cpu->arch.gdt[0])); |
159 | fixup_gdt_table(cpu, 0, ARRAY_SIZE(cpu->arch.gdt)); | 158 | fixup_gdt_table(cpu, 0, ARRAY_SIZE(cpu->arch.gdt)); |
160 | /* Mark that the GDT changed so the core knows it has to copy it again, | 159 | /* Mark that the GDT changed so the core knows it has to copy it again, |
161 | * even if the Guest is run on the same CPU. */ | 160 | * even if the Guest is run on the same CPU. */ |
@@ -169,9 +168,8 @@ void load_guest_gdt(struct lg_cpu *cpu, unsigned long table, u32 num) | |||
169 | void guest_load_tls(struct lg_cpu *cpu, unsigned long gtls) | 168 | void guest_load_tls(struct lg_cpu *cpu, unsigned long gtls) |
170 | { | 169 | { |
171 | struct desc_struct *tls = &cpu->arch.gdt[GDT_ENTRY_TLS_MIN]; | 170 | struct desc_struct *tls = &cpu->arch.gdt[GDT_ENTRY_TLS_MIN]; |
172 | struct lguest *lg = cpu->lg; | ||
173 | 171 | ||
174 | __lgread(lg, tls, gtls, sizeof(*tls)*GDT_ENTRY_TLS_ENTRIES); | 172 | __lgread(cpu, tls, gtls, sizeof(*tls)*GDT_ENTRY_TLS_ENTRIES); |
175 | fixup_gdt_table(cpu, GDT_ENTRY_TLS_MIN, GDT_ENTRY_TLS_MAX+1); | 173 | fixup_gdt_table(cpu, GDT_ENTRY_TLS_MIN, GDT_ENTRY_TLS_MAX+1); |
176 | /* Note that just the TLS entries have changed. */ | 174 | /* Note that just the TLS entries have changed. */ |
177 | cpu->changed |= CHANGED_GDT_TLS; | 175 | cpu->changed |= CHANGED_GDT_TLS; |
diff --git a/drivers/lguest/x86/core.c b/drivers/lguest/x86/core.c index fd6a8512443c..e9c3ba8aa1ec 100644 --- a/drivers/lguest/x86/core.c +++ b/drivers/lguest/x86/core.c | |||
@@ -117,7 +117,6 @@ static void run_guest_once(struct lg_cpu *cpu, struct lguest_pages *pages) | |||
117 | { | 117 | { |
118 | /* This is a dummy value we need for GCC's sake. */ | 118 | /* This is a dummy value we need for GCC's sake. */ |
119 | unsigned int clobber; | 119 | unsigned int clobber; |
120 | struct lguest *lg = cpu->lg; | ||
121 | 120 | ||
122 | /* Copy the guest-specific information into this CPU's "struct | 121 | /* Copy the guest-specific information into this CPU's "struct |
123 | * lguest_pages". */ | 122 | * lguest_pages". */ |
@@ -144,7 +143,7 @@ static void run_guest_once(struct lg_cpu *cpu, struct lguest_pages *pages) | |||
144 | * 0-th argument above, ie "a"). %ebx contains the | 143 | * 0-th argument above, ie "a"). %ebx contains the |
145 | * physical address of the Guest's top-level page | 144 | * physical address of the Guest's top-level page |
146 | * directory. */ | 145 | * directory. */ |
147 | : "0"(pages), "1"(__pa(lg->pgdirs[cpu->cpu_pgd].pgdir)) | 146 | : "0"(pages), "1"(__pa(cpu->lg->pgdirs[cpu->cpu_pgd].pgdir)) |
148 | /* We tell gcc that all these registers could change, | 147 | /* We tell gcc that all these registers could change, |
149 | * which means we don't have to save and restore them in | 148 | * which means we don't have to save and restore them in |
150 | * the Switcher. */ | 149 | * the Switcher. */ |
@@ -217,7 +216,6 @@ void lguest_arch_run_guest(struct lg_cpu *cpu) | |||
217 | * instructions and skip over it. We return true if we did. */ | 216 | * instructions and skip over it. We return true if we did. */ |
218 | static int emulate_insn(struct lg_cpu *cpu) | 217 | static int emulate_insn(struct lg_cpu *cpu) |
219 | { | 218 | { |
220 | struct lguest *lg = cpu->lg; | ||
221 | u8 insn; | 219 | u8 insn; |
222 | unsigned int insnlen = 0, in = 0, shift = 0; | 220 | unsigned int insnlen = 0, in = 0, shift = 0; |
223 | /* The eip contains the *virtual* address of the Guest's instruction: | 221 | /* The eip contains the *virtual* address of the Guest's instruction: |
@@ -231,7 +229,7 @@ static int emulate_insn(struct lg_cpu *cpu) | |||
231 | return 0; | 229 | return 0; |
232 | 230 | ||
233 | /* Decoding x86 instructions is icky. */ | 231 | /* Decoding x86 instructions is icky. */ |
234 | insn = lgread(lg, physaddr, u8); | 232 | insn = lgread(cpu, physaddr, u8); |
235 | 233 | ||
236 | /* 0x66 is an "operand prefix". It means it's using the upper 16 bits | 234 | /* 0x66 is an "operand prefix". It means it's using the upper 16 bits |
237 | of the eax register. */ | 235 | of the eax register. */ |
@@ -239,7 +237,7 @@ static int emulate_insn(struct lg_cpu *cpu) | |||
239 | shift = 16; | 237 | shift = 16; |
240 | /* The instruction is 1 byte so far, read the next byte. */ | 238 | /* The instruction is 1 byte so far, read the next byte. */ |
241 | insnlen = 1; | 239 | insnlen = 1; |
242 | insn = lgread(lg, physaddr + insnlen, u8); | 240 | insn = lgread(cpu, physaddr + insnlen, u8); |
243 | } | 241 | } |
244 | 242 | ||
245 | /* We can ignore the lower bit for the moment and decode the 4 opcodes | 243 | /* We can ignore the lower bit for the moment and decode the 4 opcodes |
@@ -283,7 +281,6 @@ static int emulate_insn(struct lg_cpu *cpu) | |||
283 | /*H:050 Once we've re-enabled interrupts, we look at why the Guest exited. */ | 281 | /*H:050 Once we've re-enabled interrupts, we look at why the Guest exited. */ |
284 | void lguest_arch_handle_trap(struct lg_cpu *cpu) | 282 | void lguest_arch_handle_trap(struct lg_cpu *cpu) |
285 | { | 283 | { |
286 | struct lguest *lg = cpu->lg; | ||
287 | switch (cpu->regs->trapnum) { | 284 | switch (cpu->regs->trapnum) { |
288 | case 13: /* We've intercepted a General Protection Fault. */ | 285 | case 13: /* We've intercepted a General Protection Fault. */ |
289 | /* Check if this was one of those annoying IN or OUT | 286 | /* Check if this was one of those annoying IN or OUT |
@@ -315,9 +312,10 @@ void lguest_arch_handle_trap(struct lg_cpu *cpu) | |||
315 | * Note that if the Guest were really messed up, this could | 312 | * Note that if the Guest were really messed up, this could |
316 | * happen before it's done the LHCALL_LGUEST_INIT hypercall, so | 313 | * happen before it's done the LHCALL_LGUEST_INIT hypercall, so |
317 | * lg->lguest_data could be NULL */ | 314 | * lg->lguest_data could be NULL */ |
318 | if (lg->lguest_data && | 315 | if (cpu->lg->lguest_data && |
319 | put_user(cpu->arch.last_pagefault, &lg->lguest_data->cr2)) | 316 | put_user(cpu->arch.last_pagefault, |
320 | kill_guest(lg, "Writing cr2"); | 317 | &cpu->lg->lguest_data->cr2)) |
318 | kill_guest(cpu, "Writing cr2"); | ||
321 | break; | 319 | break; |
322 | case 7: /* We've intercepted a Device Not Available fault. */ | 320 | case 7: /* We've intercepted a Device Not Available fault. */ |
323 | /* If the Guest doesn't want to know, we already restored the | 321 | /* If the Guest doesn't want to know, we already restored the |
@@ -345,7 +343,7 @@ void lguest_arch_handle_trap(struct lg_cpu *cpu) | |||
345 | /* If the Guest doesn't have a handler (either it hasn't | 343 | /* If the Guest doesn't have a handler (either it hasn't |
346 | * registered any yet, or it's one of the faults we don't let | 344 | * registered any yet, or it's one of the faults we don't let |
347 | * it handle), it dies with a cryptic error message. */ | 345 | * it handle), it dies with a cryptic error message. */ |
348 | kill_guest(lg, "unhandled trap %li at %#lx (%#lx)", | 346 | kill_guest(cpu, "unhandled trap %li at %#lx (%#lx)", |
349 | cpu->regs->trapnum, cpu->regs->eip, | 347 | cpu->regs->trapnum, cpu->regs->eip, |
350 | cpu->regs->trapnum == 14 ? cpu->arch.last_pagefault | 348 | cpu->regs->trapnum == 14 ? cpu->arch.last_pagefault |
351 | : cpu->regs->errcode); | 349 | : cpu->regs->errcode); |
@@ -514,11 +512,11 @@ int lguest_arch_do_hcall(struct lg_cpu *cpu, struct hcall_args *args) | |||
514 | int lguest_arch_init_hypercalls(struct lg_cpu *cpu) | 512 | int lguest_arch_init_hypercalls(struct lg_cpu *cpu) |
515 | { | 513 | { |
516 | u32 tsc_speed; | 514 | u32 tsc_speed; |
517 | struct lguest *lg = cpu->lg; | ||
518 | 515 | ||
519 | /* The pointer to the Guest's "struct lguest_data" is the only | 516 | /* The pointer to the Guest's "struct lguest_data" is the only |
520 | * argument. We check that address now. */ | 517 | * argument. We check that address now. */ |
521 | if (!lguest_address_ok(lg, cpu->hcall->arg1, sizeof(*lg->lguest_data))) | 518 | if (!lguest_address_ok(cpu->lg, cpu->hcall->arg1, |
519 | sizeof(*cpu->lg->lguest_data))) | ||
522 | return -EFAULT; | 520 | return -EFAULT; |
523 | 521 | ||
524 | /* Having checked it, we simply set lg->lguest_data to point straight | 522 | /* Having checked it, we simply set lg->lguest_data to point straight |
@@ -526,7 +524,7 @@ int lguest_arch_init_hypercalls(struct lg_cpu *cpu) | |||
526 | * copy_to_user/from_user from now on, instead of lgread/write. I put | 524 | * copy_to_user/from_user from now on, instead of lgread/write. I put |
527 | * this in to show that I'm not immune to writing stupid | 525 | * this in to show that I'm not immune to writing stupid |
528 | * optimizations. */ | 526 | * optimizations. */ |
529 | lg->lguest_data = lg->mem_base + cpu->hcall->arg1; | 527 | cpu->lg->lguest_data = cpu->lg->mem_base + cpu->hcall->arg1; |
530 | 528 | ||
531 | /* We insist that the Time Stamp Counter exist and doesn't change with | 529 | /* We insist that the Time Stamp Counter exist and doesn't change with |
532 | * cpu frequency. Some devious chip manufacturers decided that TSC | 530 | * cpu frequency. Some devious chip manufacturers decided that TSC |
@@ -539,12 +537,12 @@ int lguest_arch_init_hypercalls(struct lg_cpu *cpu) | |||
539 | tsc_speed = tsc_khz; | 537 | tsc_speed = tsc_khz; |
540 | else | 538 | else |
541 | tsc_speed = 0; | 539 | tsc_speed = 0; |
542 | if (put_user(tsc_speed, &lg->lguest_data->tsc_khz)) | 540 | if (put_user(tsc_speed, &cpu->lg->lguest_data->tsc_khz)) |
543 | return -EFAULT; | 541 | return -EFAULT; |
544 | 542 | ||
545 | /* The interrupt code might not like the system call vector. */ | 543 | /* The interrupt code might not like the system call vector. */ |
546 | if (!check_syscall_vector(lg)) | 544 | if (!check_syscall_vector(cpu->lg)) |
547 | kill_guest(lg, "bad syscall vector"); | 545 | kill_guest(cpu, "bad syscall vector"); |
548 | 546 | ||
549 | return 0; | 547 | return 0; |
550 | } | 548 | } |