lguest_user.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445
  1. /*P:200 This contains all the /dev/lguest code, whereby the userspace
  2. * launcher controls and communicates with the Guest. For example,
  3. * the first write will tell us the Guest's memory layout and entry
  4. * point. A read will run the Guest until something happens, such as
  5. * a signal or the Guest accessing a device.
  6. :*/
  7. #include <linux/uaccess.h>
  8. #include <linux/miscdevice.h>
  9. #include <linux/fs.h>
  10. #include <linux/sched.h>
  11. #include <linux/file.h>
  12. #include <linux/slab.h>
  13. #include <linux/export.h>
  14. #include "lg.h"
  15. /*L:052
  16. The Launcher can get the registers, and also set some of them.
  17. */
  18. static int getreg_setup(struct lg_cpu *cpu, const unsigned long __user *input)
  19. {
  20. unsigned long which;
  21. /* We re-use the ptrace structure to specify which register to read. */
  22. if (get_user(which, input) != 0)
  23. return -EFAULT;
  24. /*
  25. * We set up the cpu register pointer, and their next read will
  26. * actually get the value (instead of running the guest).
  27. *
  28. * The last argument 'true' says we can access any register.
  29. */
  30. cpu->reg_read = lguest_arch_regptr(cpu, which, true);
  31. if (!cpu->reg_read)
  32. return -ENOENT;
  33. /* And because this is a write() call, we return the length used. */
  34. return sizeof(unsigned long) * 2;
  35. }
  36. static int setreg(struct lg_cpu *cpu, const unsigned long __user *input)
  37. {
  38. unsigned long which, value, *reg;
  39. /* We re-use the ptrace structure to specify which register to read. */
  40. if (get_user(which, input) != 0)
  41. return -EFAULT;
  42. input++;
  43. if (get_user(value, input) != 0)
  44. return -EFAULT;
  45. /* The last argument 'false' means we can't access all registers. */
  46. reg = lguest_arch_regptr(cpu, which, false);
  47. if (!reg)
  48. return -ENOENT;
  49. *reg = value;
  50. /* And because this is a write() call, we return the length used. */
  51. return sizeof(unsigned long) * 3;
  52. }
  53. /*L:050
  54. * Sending an interrupt is done by writing LHREQ_IRQ and an interrupt
  55. * number to /dev/lguest.
  56. */
  57. static int user_send_irq(struct lg_cpu *cpu, const unsigned long __user *input)
  58. {
  59. unsigned long irq;
  60. if (get_user(irq, input) != 0)
  61. return -EFAULT;
  62. if (irq >= LGUEST_IRQS)
  63. return -EINVAL;
  64. /*
  65. * Next time the Guest runs, the core code will see if it can deliver
  66. * this interrupt.
  67. */
  68. set_interrupt(cpu, irq);
  69. return 0;
  70. }
  71. /*L:053
  72. * Deliver a trap: this is used by the Launcher if it can't emulate
  73. * an instruction.
  74. */
  75. static int trap(struct lg_cpu *cpu, const unsigned long __user *input)
  76. {
  77. unsigned long trapnum;
  78. if (get_user(trapnum, input) != 0)
  79. return -EFAULT;
  80. if (!deliver_trap(cpu, trapnum))
  81. return -EINVAL;
  82. return 0;
  83. }
  84. /*L:040
  85. * Once our Guest is initialized, the Launcher makes it run by reading
  86. * from /dev/lguest.
  87. */
  88. static ssize_t read(struct file *file, char __user *user, size_t size,loff_t*o)
  89. {
  90. struct lguest *lg = file->private_data;
  91. struct lg_cpu *cpu;
  92. unsigned int cpu_id = *o;
  93. /* You must write LHREQ_INITIALIZE first! */
  94. if (!lg)
  95. return -EINVAL;
  96. /* Watch out for arbitrary vcpu indexes! */
  97. if (cpu_id >= lg->nr_cpus)
  98. return -EINVAL;
  99. cpu = &lg->cpus[cpu_id];
  100. /* If you're not the task which owns the Guest, go away. */
  101. if (current != cpu->tsk)
  102. return -EPERM;
  103. /* If the Guest is already dead, we indicate why */
  104. if (lg->dead) {
  105. size_t len;
  106. /* lg->dead either contains an error code, or a string. */
  107. if (IS_ERR(lg->dead))
  108. return PTR_ERR(lg->dead);
  109. /* We can only return as much as the buffer they read with. */
  110. len = min(size, strlen(lg->dead)+1);
  111. if (copy_to_user(user, lg->dead, len) != 0)
  112. return -EFAULT;
  113. return len;
  114. }
  115. /*
  116. * If we returned from read() last time because the Guest sent I/O,
  117. * clear the flag.
  118. */
  119. if (cpu->pending.trap)
  120. cpu->pending.trap = 0;
  121. /* Run the Guest until something interesting happens. */
  122. return run_guest(cpu, (unsigned long __user *)user);
  123. }
  124. /*L:025
  125. * This actually initializes a CPU. For the moment, a Guest is only
  126. * uniprocessor, so "id" is always 0.
  127. */
  128. static int lg_cpu_start(struct lg_cpu *cpu, unsigned id, unsigned long start_ip)
  129. {
  130. /* We have a limited number of CPUs in the lguest struct. */
  131. if (id >= ARRAY_SIZE(cpu->lg->cpus))
  132. return -EINVAL;
  133. /* Set up this CPU's id, and pointer back to the lguest struct. */
  134. cpu->id = id;
  135. cpu->lg = container_of(cpu, struct lguest, cpus[id]);
  136. cpu->lg->nr_cpus++;
  137. /* Each CPU has a timer it can set. */
  138. init_clockdev(cpu);
  139. /*
  140. * We need a complete page for the Guest registers: they are accessible
  141. * to the Guest and we can only grant it access to whole pages.
  142. */
  143. cpu->regs_page = get_zeroed_page(GFP_KERNEL);
  144. if (!cpu->regs_page)
  145. return -ENOMEM;
  146. /* We actually put the registers at the end of the page. */
  147. cpu->regs = (void *)cpu->regs_page + PAGE_SIZE - sizeof(*cpu->regs);
  148. /*
  149. * Now we initialize the Guest's registers, handing it the start
  150. * address.
  151. */
  152. lguest_arch_setup_regs(cpu, start_ip);
  153. /*
  154. * We keep a pointer to the Launcher task (ie. current task) for when
  155. * other Guests want to wake this one (eg. console input).
  156. */
  157. cpu->tsk = current;
  158. /*
  159. * We need to keep a pointer to the Launcher's memory map, because if
  160. * the Launcher dies we need to clean it up. If we don't keep a
  161. * reference, it is destroyed before close() is called.
  162. */
  163. cpu->mm = get_task_mm(cpu->tsk);
  164. /*
  165. * We remember which CPU's pages this Guest used last, for optimization
  166. * when the same Guest runs on the same CPU twice.
  167. */
  168. cpu->last_pages = NULL;
  169. /* No error == success. */
  170. return 0;
  171. }
  172. /*L:020
  173. * The initialization write supplies 3 pointer sized (32 or 64 bit) values (in
  174. * addition to the LHREQ_INITIALIZE value). These are:
  175. *
  176. * base: The start of the Guest-physical memory inside the Launcher memory.
  177. *
  178. * pfnlimit: The highest (Guest-physical) page number the Guest should be
  179. * allowed to access. The Guest memory lives inside the Launcher, so it sets
  180. * this to ensure the Guest can only reach its own memory.
  181. *
  182. * start: The first instruction to execute ("eip" in x86-speak).
  183. */
  184. static int initialize(struct file *file, const unsigned long __user *input)
  185. {
  186. /* "struct lguest" contains all we (the Host) know about a Guest. */
  187. struct lguest *lg;
  188. int err;
  189. unsigned long args[4];
  190. /*
  191. * We grab the Big Lguest lock, which protects against multiple
  192. * simultaneous initializations.
  193. */
  194. mutex_lock(&lguest_lock);
  195. /* You can't initialize twice! Close the device and start again... */
  196. if (file->private_data) {
  197. err = -EBUSY;
  198. goto unlock;
  199. }
  200. if (copy_from_user(args, input, sizeof(args)) != 0) {
  201. err = -EFAULT;
  202. goto unlock;
  203. }
  204. lg = kzalloc(sizeof(*lg), GFP_KERNEL);
  205. if (!lg) {
  206. err = -ENOMEM;
  207. goto unlock;
  208. }
  209. /* Populate the easy fields of our "struct lguest" */
  210. lg->mem_base = (void __user *)args[0];
  211. lg->pfn_limit = args[1];
  212. lg->device_limit = args[3];
  213. /* This is the first cpu (cpu 0) and it will start booting at args[2] */
  214. err = lg_cpu_start(&lg->cpus[0], 0, args[2]);
  215. if (err)
  216. goto free_lg;
  217. /*
  218. * Initialize the Guest's shadow page tables. This allocates
  219. * memory, so can fail.
  220. */
  221. err = init_guest_pagetable(lg);
  222. if (err)
  223. goto free_regs;
  224. /* We keep our "struct lguest" in the file's private_data. */
  225. file->private_data = lg;
  226. mutex_unlock(&lguest_lock);
  227. /* And because this is a write() call, we return the length used. */
  228. return sizeof(args);
  229. free_regs:
  230. /* FIXME: This should be in free_vcpu */
  231. free_page(lg->cpus[0].regs_page);
  232. free_lg:
  233. kfree(lg);
  234. unlock:
  235. mutex_unlock(&lguest_lock);
  236. return err;
  237. }
  238. /*L:010
  239. * The first operation the Launcher does must be a write. All writes
  240. * start with an unsigned long number: for the first write this must be
  241. * LHREQ_INITIALIZE to set up the Guest. After that the Launcher can use
  242. * writes of other values to send interrupts or set up receipt of notifications.
  243. *
  244. * Note that we overload the "offset" in the /dev/lguest file to indicate what
  245. * CPU number we're dealing with. Currently this is always 0 since we only
  246. * support uniprocessor Guests, but you can see the beginnings of SMP support
  247. * here.
  248. */
  249. static ssize_t write(struct file *file, const char __user *in,
  250. size_t size, loff_t *off)
  251. {
  252. /*
  253. * Once the Guest is initialized, we hold the "struct lguest" in the
  254. * file private data.
  255. */
  256. struct lguest *lg = file->private_data;
  257. const unsigned long __user *input = (const unsigned long __user *)in;
  258. unsigned long req;
  259. struct lg_cpu *uninitialized_var(cpu);
  260. unsigned int cpu_id = *off;
  261. /* The first value tells us what this request is. */
  262. if (get_user(req, input) != 0)
  263. return -EFAULT;
  264. input++;
  265. /* If you haven't initialized, you must do that first. */
  266. if (req != LHREQ_INITIALIZE) {
  267. if (!lg || (cpu_id >= lg->nr_cpus))
  268. return -EINVAL;
  269. cpu = &lg->cpus[cpu_id];
  270. /* Once the Guest is dead, you can only read() why it died. */
  271. if (lg->dead)
  272. return -ENOENT;
  273. }
  274. switch (req) {
  275. case LHREQ_INITIALIZE:
  276. return initialize(file, input);
  277. case LHREQ_IRQ:
  278. return user_send_irq(cpu, input);
  279. case LHREQ_GETREG:
  280. return getreg_setup(cpu, input);
  281. case LHREQ_SETREG:
  282. return setreg(cpu, input);
  283. case LHREQ_TRAP:
  284. return trap(cpu, input);
  285. default:
  286. return -EINVAL;
  287. }
  288. }
  289. static int open(struct inode *inode, struct file *file)
  290. {
  291. file->private_data = NULL;
  292. return 0;
  293. }
  294. /*L:060
  295. * The final piece of interface code is the close() routine. It reverses
  296. * everything done in initialize(). This is usually called because the
  297. * Launcher exited.
  298. *
  299. * Note that the close routine returns 0 or a negative error number: it can't
  300. * really fail, but it can whine. I blame Sun for this wart, and K&R C for
  301. * letting them do it.
  302. :*/
  303. static int close(struct inode *inode, struct file *file)
  304. {
  305. struct lguest *lg = file->private_data;
  306. unsigned int i;
  307. /* If we never successfully initialized, there's nothing to clean up */
  308. if (!lg)
  309. return 0;
  310. /*
  311. * We need the big lock, to protect from inter-guest I/O and other
  312. * Launchers initializing guests.
  313. */
  314. mutex_lock(&lguest_lock);
  315. /* Free up the shadow page tables for the Guest. */
  316. free_guest_pagetable(lg);
  317. for (i = 0; i < lg->nr_cpus; i++) {
  318. /* Cancels the hrtimer set via LHCALL_SET_CLOCKEVENT. */
  319. hrtimer_cancel(&lg->cpus[i].hrt);
  320. /* We can free up the register page we allocated. */
  321. free_page(lg->cpus[i].regs_page);
  322. /*
  323. * Now all the memory cleanups are done, it's safe to release
  324. * the Launcher's memory management structure.
  325. */
  326. mmput(lg->cpus[i].mm);
  327. }
  328. /*
  329. * If lg->dead doesn't contain an error code it will be NULL or a
  330. * kmalloc()ed string, either of which is ok to hand to kfree().
  331. */
  332. if (!IS_ERR(lg->dead))
  333. kfree(lg->dead);
  334. /* Free the memory allocated to the lguest_struct */
  335. kfree(lg);
  336. /* Release lock and exit. */
  337. mutex_unlock(&lguest_lock);
  338. return 0;
  339. }
  340. /*L:000
  341. * Welcome to our journey through the Launcher!
  342. *
  343. * The Launcher is the Host userspace program which sets up, runs and services
  344. * the Guest. In fact, many comments in the Drivers which refer to "the Host"
  345. * doing things are inaccurate: the Launcher does all the device handling for
  346. * the Guest, but the Guest can't know that.
  347. *
  348. * Just to confuse you: to the Host kernel, the Launcher *is* the Guest and we
  349. * shall see more of that later.
  350. *
  351. * We begin our understanding with the Host kernel interface which the Launcher
  352. * uses: reading and writing a character device called /dev/lguest. All the
  353. * work happens in the read(), write() and close() routines:
  354. */
  355. static const struct file_operations lguest_fops = {
  356. .owner = THIS_MODULE,
  357. .open = open,
  358. .release = close,
  359. .write = write,
  360. .read = read,
  361. .llseek = default_llseek,
  362. };
  363. /*:*/
  364. /*
  365. * This is a textbook example of a "misc" character device. Populate a "struct
  366. * miscdevice" and register it with misc_register().
  367. */
  368. static struct miscdevice lguest_dev = {
  369. .minor = MISC_DYNAMIC_MINOR,
  370. .name = "lguest",
  371. .fops = &lguest_fops,
  372. };
  373. int __init lguest_device_init(void)
  374. {
  375. return misc_register(&lguest_dev);
  376. }
  377. void __exit lguest_device_remove(void)
  378. {
  379. misc_deregister(&lguest_dev);
  380. }