1 /*P:200 This contains all the /dev/lguest code, whereby the userspace launcher
2 * controls and communicates with the Guest. For example, the first write will
3 * tell us the Guest's memory layout, pagetable, entry point and kernel address
4 * offset. A read will run the Guest until something happens, such as a signal
5 * or the Guest doing a NOTIFY out to the Launcher. :*/
6 #include <linux/uaccess.h>
7 #include <linux/miscdevice.h>
11 /*L:055 When something happens, the Waker process needs a way to stop the
12 * kernel running the Guest and return to the Launcher. So the Waker writes
13 * LHREQ_BREAK and the value "1" to /dev/lguest to do this. Once the Launcher
14 * has done whatever needs attention, it writes LHREQ_BREAK and "0" to release
16 static int break_guest_out(struct lguest
*lg
, const unsigned long __user
*input
)
20 /* Fetch whether they're turning break on or off. */
21 if (get_user(on
, input
) != 0)
26 /* Pop it out of the Guest (may be running on different CPU) */
27 wake_up_process(lg
->tsk
);
28 /* Wait for them to reset it */
29 return wait_event_interruptible(lg
->break_wq
, !lg
->break_out
);
32 wake_up(&lg
->break_wq
);
37 /*L:050 Sending an interrupt is done by writing LHREQ_IRQ and an interrupt
38 * number to /dev/lguest. */
39 static int user_send_irq(struct lg_cpu
*cpu
, const unsigned long __user
*input
)
43 if (get_user(irq
, input
) != 0)
45 if (irq
>= LGUEST_IRQS
)
47 /* Next time the Guest runs, the core code will see if it can deliver
49 set_bit(irq
, cpu
->irqs_pending
);
53 /*L:040 Once our Guest is initialized, the Launcher makes it run by reading
54 * from /dev/lguest. */
55 static ssize_t
read(struct file
*file
, char __user
*user
, size_t size
,loff_t
*o
)
57 struct lguest
*lg
= file
->private_data
;
59 unsigned int cpu_id
= *o
;
61 /* You must write LHREQ_INITIALIZE first! */
65 /* Watch out for arbitrary vcpu indexes! */
66 if (cpu_id
>= lg
->nr_cpus
)
69 cpu
= &lg
->cpus
[cpu_id
];
71 /* If you're not the task which owns the Guest, go away. */
72 if (current
!= lg
->tsk
)
75 /* If the guest is already dead, we indicate why */
79 /* lg->dead either contains an error code, or a string. */
81 return PTR_ERR(lg
->dead
);
83 /* We can only return as much as the buffer they read with. */
84 len
= min(size
, strlen(lg
->dead
)+1);
85 if (copy_to_user(user
, lg
->dead
, len
) != 0)
90 /* If we returned from read() last time because the Guest notified,
92 if (lg
->pending_notify
)
93 lg
->pending_notify
= 0;
95 /* Run the Guest until something interesting happens. */
96 return run_guest(cpu
, (unsigned long __user
*)user
);
99 static int lg_cpu_start(struct lg_cpu
*cpu
, unsigned id
, unsigned long start_ip
)
105 cpu
->lg
= container_of((cpu
- id
), struct lguest
, cpus
[0]);
112 /*L:020 The initialization write supplies 4 pointer sized (32 or 64 bit)
113 * values (in addition to the LHREQ_INITIALIZE value). These are:
115 * base: The start of the Guest-physical memory inside the Launcher memory.
117 * pfnlimit: The highest (Guest-physical) page number the Guest should be
118 * allowed to access. The Guest memory lives inside the Launcher, so it sets
119 * this to ensure the Guest can only reach its own memory.
121 * pgdir: The (Guest-physical) address of the top of the initial Guest
122 * pagetables (which are set up by the Launcher).
124 * start: The first instruction to execute ("eip" in x86-speak).
126 static int initialize(struct file
*file
, const unsigned long __user
*input
)
128 /* "struct lguest" contains everything we (the Host) know about a
132 unsigned long args
[4];
134 /* We grab the Big Lguest lock, which protects against multiple
135 * simultaneous initializations. */
136 mutex_lock(&lguest_lock
);
137 /* You can't initialize twice! Close the device and start again... */
138 if (file
->private_data
) {
143 if (copy_from_user(args
, input
, sizeof(args
)) != 0) {
148 lg
= kzalloc(sizeof(*lg
), GFP_KERNEL
);
154 /* Populate the easy fields of our "struct lguest" */
155 lg
->mem_base
= (void __user
*)(long)args
[0];
156 lg
->pfn_limit
= args
[1];
158 /* This is the first cpu */
159 err
= lg_cpu_start(&lg
->cpus
[0], 0, args
[3]);
163 /* We need a complete page for the Guest registers: they are accessible
164 * to the Guest and we can only grant it access to whole pages. */
165 lg
->regs_page
= get_zeroed_page(GFP_KERNEL
);
166 if (!lg
->regs_page
) {
170 /* We actually put the registers at the bottom of the page. */
171 lg
->regs
= (void *)lg
->regs_page
+ PAGE_SIZE
- sizeof(*lg
->regs
);
173 /* Initialize the Guest's shadow page tables, using the toplevel
174 * address the Launcher gave us. This allocates memory, so can
176 err
= init_guest_pagetable(lg
, args
[2]);
180 /* Now we initialize the Guest's registers, handing it the start
182 lguest_arch_setup_regs(lg
, args
[3]);
184 /* We keep a pointer to the Launcher task (ie. current task) for when
185 * other Guests want to wake this one (inter-Guest I/O). */
187 /* We need to keep a pointer to the Launcher's memory map, because if
188 * the Launcher dies we need to clean it up. If we don't keep a
189 * reference, it is destroyed before close() is called. */
190 lg
->mm
= get_task_mm(lg
->tsk
);
192 /* Initialize the queue for the waker to wait on */
193 init_waitqueue_head(&lg
->break_wq
);
195 /* We remember which CPU's pages this Guest used last, for optimization
196 * when the same Guest runs on the same CPU twice. */
197 lg
->last_pages
= NULL
;
199 /* We keep our "struct lguest" in the file's private_data. */
200 file
->private_data
= lg
;
202 mutex_unlock(&lguest_lock
);
204 /* And because this is a write() call, we return the length used. */
208 free_page(lg
->regs_page
);
212 mutex_unlock(&lguest_lock
);
216 /*L:010 The first operation the Launcher does must be a write. All writes
217 * start with an unsigned long number: for the first write this must be
218 * LHREQ_INITIALIZE to set up the Guest. After that the Launcher can use
219 * writes of other values to send interrupts. */
220 static ssize_t
write(struct file
*file
, const char __user
*in
,
221 size_t size
, loff_t
*off
)
223 /* Once the guest is initialized, we hold the "struct lguest" in the
224 * file private data. */
225 struct lguest
*lg
= file
->private_data
;
226 const unsigned long __user
*input
= (const unsigned long __user
*)in
;
228 struct lg_cpu
*uninitialized_var(cpu
);
229 unsigned int cpu_id
= *off
;
231 if (get_user(req
, input
) != 0)
235 /* If you haven't initialized, you must do that first. */
236 if (req
!= LHREQ_INITIALIZE
) {
237 if (!lg
|| (cpu_id
>= lg
->nr_cpus
))
239 cpu
= &lg
->cpus
[cpu_id
];
244 /* Once the Guest is dead, all you can do is read() why it died. */
248 /* If you're not the task which owns the Guest, you can only break */
249 if (lg
&& current
!= lg
->tsk
&& req
!= LHREQ_BREAK
)
253 case LHREQ_INITIALIZE
:
254 return initialize(file
, input
);
256 return user_send_irq(cpu
, input
);
258 return break_guest_out(lg
, input
);
264 /*L:060 The final piece of interface code is the close() routine. It reverses
265 * everything done in initialize(). This is usually called because the
268 * Note that the close routine returns 0 or a negative error number: it can't
269 * really fail, but it can whine. I blame Sun for this wart, and K&R C for
270 * letting them do it. :*/
271 static int close(struct inode
*inode
, struct file
*file
)
273 struct lguest
*lg
= file
->private_data
;
276 /* If we never successfully initialized, there's nothing to clean up */
280 /* We need the big lock, to protect from inter-guest I/O and other
281 * Launchers initializing guests. */
282 mutex_lock(&lguest_lock
);
283 for (i
= 0; i
< lg
->nr_cpus
; i
++)
284 /* Cancels the hrtimer set via LHCALL_SET_CLOCKEVENT. */
285 hrtimer_cancel(&lg
->cpus
[i
].hrt
);
286 /* Free up the shadow page tables for the Guest. */
287 free_guest_pagetable(lg
);
288 /* Now all the memory cleanups are done, it's safe to release the
289 * Launcher's memory management structure. */
291 /* If lg->dead doesn't contain an error code it will be NULL or a
292 * kmalloc()ed string, either of which is ok to hand to kfree(). */
293 if (!IS_ERR(lg
->dead
))
295 /* We can free up the register page we allocated. */
296 free_page(lg
->regs_page
);
297 /* We clear the entire structure, which also marks it as free for the
299 memset(lg
, 0, sizeof(*lg
));
300 /* Release lock and exit. */
301 mutex_unlock(&lguest_lock
);
307 * Welcome to our journey through the Launcher!
309 * The Launcher is the Host userspace program which sets up, runs and services
310 * the Guest. In fact, many comments in the Drivers which refer to "the Host"
311 * doing things are inaccurate: the Launcher does all the device handling for
312 * the Guest, but the Guest can't know that.
314 * Just to confuse you: to the Host kernel, the Launcher *is* the Guest and we
315 * shall see more of that later.
317 * We begin our understanding with the Host kernel interface which the Launcher
318 * uses: reading and writing a character device called /dev/lguest. All the
319 * work happens in the read(), write() and close() routines: */
320 static struct file_operations lguest_fops
= {
321 .owner
= THIS_MODULE
,
327 /* This is a textbook example of a "misc" character device. Populate a "struct
328 * miscdevice" and register it with misc_register(). */
329 static struct miscdevice lguest_dev
= {
330 .minor
= MISC_DYNAMIC_MINOR
,
332 .fops
= &lguest_fops
,
335 int __init
lguest_device_init(void)
337 return misc_register(&lguest_dev
);
340 void __exit
lguest_device_remove(void)
342 misc_deregister(&lguest_dev
);