5 #include <linux/types.h>
6 #include <linux/init.h>
7 #include <linux/stringify.h>
8 #include <linux/futex.h>
9 #include <linux/lguest.h>
10 #include <linux/lguest_launcher.h>
11 #include <linux/wait.h>
12 #include <linux/err.h>
13 #include <asm/semaphore.h>
15 #include <asm/lguest.h>
17 void free_pagetables(void);
18 int init_pagetables(struct page **switcher_page, unsigned int pages);
20 struct lguest_dma_info
22 struct list_head list;
28 u8 interrupt; /* 0 when not registered */
31 /*H:310 The page-table code owes a great debt of gratitude to Andi Kleen. He
32 * reviewed the original code which used "u32" for all page table entries, and
33 * insisted that it would be far clearer with explicit typing. I thought it
34 * was overkill, but he was right: it is much clearer than it was before.
36 * We have separate types for the Guest's ptes & pgds and the shadow ptes &
37 * pgds. There's already a Linux type for these (pte_t and pgd_t) but they
38 * change depending on kernel config options (PAE). */
40 /* Each entry is identical: lower 12 bits of flags and upper 20 bits for the
41 * "page frame number" (0 == first physical page, etc). They are different
42 * types so the compiler will warn us if we mix them improperly. */
44 struct { unsigned flags:12, pfn:20; };
45 struct { unsigned long val; } raw;
48 struct { unsigned flags:12, pfn:20; };
49 struct { unsigned long val; } raw;
52 struct { unsigned flags:12, pfn:20; };
53 struct { unsigned long val; } raw;
56 struct { unsigned flags:12, pfn:20; };
57 struct { unsigned long val; } raw;
60 /* We have two convenient macros to convert a "raw" value as handed to us by
61 * the Guest into the correct Guest PGD or PTE type. */
62 #define mkgpte(_val) ((gpte_t){.raw.val = _val})
63 #define mkgpgd(_val) ((gpgd_t){.raw.val = _val})
72 /* We have two pages shared with guests, per cpu. */
75 /* This is the stack page mapped rw in guest */
76 char spare[PAGE_SIZE - sizeof(struct lguest_regs)];
77 struct lguest_regs regs;
79 /* This is the host state & guest descriptor page, ro in guest */
80 struct lguest_ro_state state;
81 } __attribute__((aligned(PAGE_SIZE)));
85 #define CHANGED_GDT_TLS 4 /* Actually a subset of CHANGED_GDT */
88 /* The private info the thread maintains about the guest. */
91 /* At end of a page shared mapped over lguest_pages in guest. */
92 unsigned long regs_page;
93 struct lguest_regs *regs;
94 struct lguest_data __user *lguest_data;
95 struct task_struct *tsk;
96 struct mm_struct *mm; /* == tsk->mm, but that becomes NULL on exit */
98 /* This provides the offset to the base of guest-physical
99 * memory in the Launcher. */
100 void __user *mem_base;
109 /* If a hypercall was asked for, this points to the arguments. */
110 struct lguest_regs *hcall;
112 /* Do we need to stop what we're doing and return to userspace? */
114 wait_queue_head_t break_wq;
116 /* Bitmap of what has changed: see CHANGED_* above. */
118 struct lguest_pages *last_pages;
120 /* We keep a small number of these. */
122 struct pgdir pgdirs[4];
124 /* Cached wakeup: we hold a reference to this task. */
125 struct task_struct *wake;
127 unsigned long noirq_start, noirq_end;
129 unsigned long pending_dma; /* struct lguest_dma */
130 unsigned long pending_key; /* address they're sending to */
132 unsigned int stack_pages;
135 struct lguest_dma_info dma[LGUEST_MAX_DMA];
140 struct lguest_arch arch;
142 /* Virtual clock device */
145 /* Pending virtual interrupts */
146 DECLARE_BITMAP(irqs_pending, LGUEST_IRQS);
149 extern struct mutex lguest_lock;
152 u32 lgread_u32(struct lguest *lg, unsigned long addr);
153 void lgwrite_u32(struct lguest *lg, unsigned long addr, u32 val);
154 void lgread(struct lguest *lg, void *buf, unsigned long addr, unsigned len);
155 void lgwrite(struct lguest *lg, unsigned long, const void *buf, unsigned len);
156 int lguest_address_ok(const struct lguest *lg,
157 unsigned long addr, unsigned long len);
158 int run_guest(struct lguest *lg, unsigned long __user *user);
161 /* interrupts_and_traps.c: */
162 void maybe_do_interrupt(struct lguest *lg);
163 int deliver_trap(struct lguest *lg, unsigned int num);
164 void load_guest_idt_entry(struct lguest *lg, unsigned int i, u32 low, u32 hi);
165 void guest_set_stack(struct lguest *lg, u32 seg, u32 esp, unsigned int pages);
166 void pin_stack_pages(struct lguest *lg);
167 void setup_default_idt_entries(struct lguest_ro_state *state,
168 const unsigned long *def);
169 void copy_traps(const struct lguest *lg, struct desc_struct *idt,
170 const unsigned long *def);
171 void guest_set_clockevent(struct lguest *lg, unsigned long delta);
172 void init_clockdev(struct lguest *lg);
175 void setup_default_gdt_entries(struct lguest_ro_state *state);
176 void setup_guest_gdt(struct lguest *lg);
177 void load_guest_gdt(struct lguest *lg, unsigned long table, u32 num);
178 void guest_load_tls(struct lguest *lg, unsigned long tls_array);
179 void copy_gdt(const struct lguest *lg, struct desc_struct *gdt);
180 void copy_gdt_tls(const struct lguest *lg, struct desc_struct *gdt);
183 int init_guest_pagetable(struct lguest *lg, unsigned long pgtable);
184 void free_guest_pagetable(struct lguest *lg);
185 void guest_new_pagetable(struct lguest *lg, unsigned long pgtable);
186 void guest_set_pmd(struct lguest *lg, unsigned long cr3, u32 i);
187 void guest_pagetable_clear_all(struct lguest *lg);
188 void guest_pagetable_flush_user(struct lguest *lg);
189 void guest_set_pte(struct lguest *lg, unsigned long cr3,
190 unsigned long vaddr, gpte_t val);
191 void map_switcher_in_guest(struct lguest *lg, struct lguest_pages *pages);
192 int demand_page(struct lguest *info, unsigned long cr2, int errcode);
193 void pin_page(struct lguest *lg, unsigned long vaddr);
196 void lguest_arch_host_init(void);
197 void lguest_arch_host_fini(void);
198 void lguest_arch_run_guest(struct lguest *lg);
199 void lguest_arch_handle_trap(struct lguest *lg);
201 /* <arch>/switcher.S: */
202 extern char start_switcher_text[], end_switcher_text[], switch_to_guest[];
205 int lguest_device_init(void);
206 void lguest_device_remove(void);
209 void lguest_io_init(void);
210 int bind_dma(struct lguest *lg,
211 unsigned long key, unsigned long udma, u16 numdmas, u8 interrupt);
212 void send_dma(struct lguest *info, unsigned long key, unsigned long udma);
213 void release_all_dma(struct lguest *lg);
214 unsigned long get_dma_buffer(struct lguest *lg, unsigned long key,
215 unsigned long *interrupt);
218 void do_hypercalls(struct lguest *lg);
219 void write_timestamp(struct lguest *lg);
222 * Let's step aside for the moment, to study one important routine that's used
223 * widely in the Host code.
225 * There are many cases where the Guest does something invalid, like pass crap
226 * to a hypercall. Since only the Guest kernel can make hypercalls, it's quite
227 * acceptable to simply terminate the Guest and give the Launcher a nicely
228 * formatted reason. It's also simpler for the Guest itself, which doesn't
229 * need to check most hypercalls for "success"; if you're still running, it
232 * Once this is called, the Guest will never run again, so most Host code can
233 * call this then continue as if nothing had happened. This means many
234 * functions don't have to explicitly return an error code, which keeps the
237 * It also means that this can be called more than once: only the first one is
238 * remembered. The only trick is that we still need to kill the Guest even if
239 * we can't allocate memory to store the reason. Linux has a neat way of
240 * packing error codes into invalid pointers, so we use that here.
242 * Like any macro which uses an "if", it is safely wrapped in a run-once "do {
245 #define kill_guest(lg, fmt...) \
248 (lg)->dead = kasprintf(GFP_ATOMIC, fmt); \
250 (lg)->dead = ERR_PTR(-ENOMEM); \
253 /* (End of aside) :*/
255 static inline unsigned long guest_pa(struct lguest *lg, unsigned long vaddr)
257 return vaddr - lg->page_offset;
259 #endif /* __ASSEMBLY__ */
260 #endif /* _LGUEST_H */