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 /* Do we need to stop what we're doing and return to userspace? */
111 wait_queue_head_t break_wq;
113 /* Bitmap of what has changed: see CHANGED_* above. */
115 struct lguest_pages *last_pages;
117 /* We keep a small number of these. */
119 struct pgdir pgdirs[4];
121 /* Cached wakeup: we hold a reference to this task. */
122 struct task_struct *wake;
124 unsigned long noirq_start, noirq_end;
126 unsigned long pending_dma; /* struct lguest_dma */
127 unsigned long pending_key; /* address they're sending to */
129 unsigned int stack_pages;
132 struct lguest_dma_info dma[LGUEST_MAX_DMA];
137 struct lguest_arch arch;
139 /* Virtual clock device */
142 /* Pending virtual interrupts */
143 DECLARE_BITMAP(irqs_pending, LGUEST_IRQS);
146 extern struct mutex lguest_lock;
149 u32 lgread_u32(struct lguest *lg, unsigned long addr);
150 void lgwrite_u32(struct lguest *lg, unsigned long addr, u32 val);
151 void lgread(struct lguest *lg, void *buf, unsigned long addr, unsigned len);
152 void lgwrite(struct lguest *lg, unsigned long, const void *buf, unsigned len);
153 int lguest_address_ok(const struct lguest *lg,
154 unsigned long addr, unsigned long len);
155 int run_guest(struct lguest *lg, unsigned long __user *user);
158 /* interrupts_and_traps.c: */
159 void maybe_do_interrupt(struct lguest *lg);
160 int deliver_trap(struct lguest *lg, unsigned int num);
161 void load_guest_idt_entry(struct lguest *lg, unsigned int i, u32 low, u32 hi);
162 void guest_set_stack(struct lguest *lg, u32 seg, u32 esp, unsigned int pages);
163 void pin_stack_pages(struct lguest *lg);
164 void setup_default_idt_entries(struct lguest_ro_state *state,
165 const unsigned long *def);
166 void copy_traps(const struct lguest *lg, struct desc_struct *idt,
167 const unsigned long *def);
168 void guest_set_clockevent(struct lguest *lg, unsigned long delta);
169 void init_clockdev(struct lguest *lg);
172 void setup_default_gdt_entries(struct lguest_ro_state *state);
173 void setup_guest_gdt(struct lguest *lg);
174 void load_guest_gdt(struct lguest *lg, unsigned long table, u32 num);
175 void guest_load_tls(struct lguest *lg, unsigned long tls_array);
176 void copy_gdt(const struct lguest *lg, struct desc_struct *gdt);
177 void copy_gdt_tls(const struct lguest *lg, struct desc_struct *gdt);
180 int init_guest_pagetable(struct lguest *lg, unsigned long pgtable);
181 void free_guest_pagetable(struct lguest *lg);
182 void guest_new_pagetable(struct lguest *lg, unsigned long pgtable);
183 void guest_set_pmd(struct lguest *lg, unsigned long cr3, u32 i);
184 void guest_pagetable_clear_all(struct lguest *lg);
185 void guest_pagetable_flush_user(struct lguest *lg);
186 void guest_set_pte(struct lguest *lg, unsigned long cr3,
187 unsigned long vaddr, gpte_t val);
188 void map_switcher_in_guest(struct lguest *lg, struct lguest_pages *pages);
189 int demand_page(struct lguest *info, unsigned long cr2, int errcode);
190 void pin_page(struct lguest *lg, unsigned long vaddr);
193 void lguest_arch_host_init(void);
194 void lguest_arch_host_fini(void);
195 void lguest_arch_run_guest(struct lguest *lg);
196 void lguest_arch_handle_trap(struct lguest *lg);
198 /* <arch>/switcher.S: */
199 extern char start_switcher_text[], end_switcher_text[], switch_to_guest[];
202 int lguest_device_init(void);
203 void lguest_device_remove(void);
206 void lguest_io_init(void);
207 int bind_dma(struct lguest *lg,
208 unsigned long key, unsigned long udma, u16 numdmas, u8 interrupt);
209 void send_dma(struct lguest *info, unsigned long key, unsigned long udma);
210 void release_all_dma(struct lguest *lg);
211 unsigned long get_dma_buffer(struct lguest *lg, unsigned long key,
212 unsigned long *interrupt);
215 void do_hypercalls(struct lguest *lg);
216 void write_timestamp(struct lguest *lg);
219 * Let's step aside for the moment, to study one important routine that's used
220 * widely in the Host code.
222 * There are many cases where the Guest does something invalid, like pass crap
223 * to a hypercall. Since only the Guest kernel can make hypercalls, it's quite
224 * acceptable to simply terminate the Guest and give the Launcher a nicely
225 * formatted reason. It's also simpler for the Guest itself, which doesn't
226 * need to check most hypercalls for "success"; if you're still running, it
229 * Once this is called, the Guest will never run again, so most Host code can
230 * call this then continue as if nothing had happened. This means many
231 * functions don't have to explicitly return an error code, which keeps the
234 * It also means that this can be called more than once: only the first one is
235 * remembered. The only trick is that we still need to kill the Guest even if
236 * we can't allocate memory to store the reason. Linux has a neat way of
237 * packing error codes into invalid pointers, so we use that here.
239 * Like any macro which uses an "if", it is safely wrapped in a run-once "do {
242 #define kill_guest(lg, fmt...) \
245 (lg)->dead = kasprintf(GFP_ATOMIC, fmt); \
247 (lg)->dead = ERR_PTR(-ENOMEM); \
250 /* (End of aside) :*/
252 static inline unsigned long guest_pa(struct lguest *lg, unsigned long vaddr)
254 return vaddr - lg->page_offset;
256 #endif /* __ASSEMBLY__ */
257 #endif /* _LGUEST_H */