blob: 9f9a2953b3830dd42b9f1eb1f06649ed9870e5e3 [file] [log] [blame]
Rusty Russellf938d2c2007-07-26 10:41:02 -07001/*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
Rusty Russell3c6b5bf2007-10-22 11:03:26 +10003 * 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
Rusty Russell15045272007-10-22 11:24:10 +10005 * or the Guest doing a NOTIFY out to the Launcher. :*/
Rusty Russelld7e28ff2007-07-19 01:49:23 -07006#include <linux/uaccess.h>
7#include <linux/miscdevice.h>
8#include <linux/fs.h>
Glauber de Oliveira Costaca94f2b2008-01-18 23:59:07 -02009#include <linux/sched.h>
Rusty Russelldf60aee2009-06-12 22:27:09 -060010#include <linux/eventfd.h>
11#include <linux/file.h>
Rusty Russelld7e28ff2007-07-19 01:49:23 -070012#include "lg.h"
13
Rusty Russelldf60aee2009-06-12 22:27:09 -060014bool send_notify_to_eventfd(struct lg_cpu *cpu)
15{
16 unsigned int i;
17 struct lg_eventfd_map *map;
18
19 /* lg->eventfds is RCU-protected */
20 rcu_read_lock();
21 map = rcu_dereference(cpu->lg->eventfds);
22 for (i = 0; i < map->num; i++) {
23 if (map->map[i].addr == cpu->pending_notify) {
24 eventfd_signal(map->map[i].event, 1);
25 cpu->pending_notify = 0;
26 break;
27 }
28 }
29 rcu_read_unlock();
30 return cpu->pending_notify == 0;
31}
32
33static int add_eventfd(struct lguest *lg, unsigned long addr, int fd)
34{
35 struct lg_eventfd_map *new, *old = lg->eventfds;
36
37 if (!addr)
38 return -EINVAL;
39
40 /* Replace the old array with the new one, carefully: others can
41 * be accessing it at the same time */
42 new = kmalloc(sizeof(*new) + sizeof(new->map[0]) * (old->num + 1),
43 GFP_KERNEL);
44 if (!new)
45 return -ENOMEM;
46
47 /* First make identical copy. */
48 memcpy(new->map, old->map, sizeof(old->map[0]) * old->num);
49 new->num = old->num;
50
51 /* Now append new entry. */
52 new->map[new->num].addr = addr;
Davide Libenzi13389012009-06-30 11:41:11 -070053 new->map[new->num].event = eventfd_ctx_fdget(fd);
Rusty Russelldf60aee2009-06-12 22:27:09 -060054 if (IS_ERR(new->map[new->num].event)) {
55 kfree(new);
56 return PTR_ERR(new->map[new->num].event);
57 }
58 new->num++;
59
60 /* Now put new one in place. */
61 rcu_assign_pointer(lg->eventfds, new);
62
63 /* We're not in a big hurry. Wait until noone's looking at old
64 * version, then delete it. */
65 synchronize_rcu();
66 kfree(old);
67
68 return 0;
69}
70
71static int attach_eventfd(struct lguest *lg, const unsigned long __user *input)
72{
73 unsigned long addr, fd;
74 int err;
75
76 if (get_user(addr, input) != 0)
77 return -EFAULT;
78 input++;
79 if (get_user(fd, input) != 0)
80 return -EFAULT;
81
82 mutex_lock(&lguest_lock);
83 err = add_eventfd(lg, addr, fd);
84 mutex_unlock(&lguest_lock);
85
86 return 0;
87}
88
Rusty Russelldde79782007-07-26 10:41:03 -070089/*L:050 Sending an interrupt is done by writing LHREQ_IRQ and an interrupt
90 * number to /dev/lguest. */
Glauber de Oliveira Costa177e4492008-01-07 11:05:29 -020091static int user_send_irq(struct lg_cpu *cpu, const unsigned long __user *input)
Rusty Russelld7e28ff2007-07-19 01:49:23 -070092{
Jes Sorensen511801d2007-10-22 11:03:31 +100093 unsigned long irq;
Rusty Russelld7e28ff2007-07-19 01:49:23 -070094
95 if (get_user(irq, input) != 0)
96 return -EFAULT;
97 if (irq >= LGUEST_IRQS)
98 return -EINVAL;
Rusty Russell9f155a92009-06-12 22:27:08 -060099
100 set_interrupt(cpu, irq);
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700101 return 0;
102}
103
Rusty Russelldde79782007-07-26 10:41:03 -0700104/*L:040 Once our Guest is initialized, the Launcher makes it run by reading
105 * from /dev/lguest. */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700106static ssize_t read(struct file *file, char __user *user, size_t size,loff_t*o)
107{
108 struct lguest *lg = file->private_data;
Glauber de Oliveira Costad0953d42008-01-07 11:05:25 -0200109 struct lg_cpu *cpu;
110 unsigned int cpu_id = *o;
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700111
Rusty Russelldde79782007-07-26 10:41:03 -0700112 /* You must write LHREQ_INITIALIZE first! */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700113 if (!lg)
114 return -EINVAL;
115
Glauber de Oliveira Costad0953d42008-01-07 11:05:25 -0200116 /* Watch out for arbitrary vcpu indexes! */
117 if (cpu_id >= lg->nr_cpus)
118 return -EINVAL;
119
120 cpu = &lg->cpus[cpu_id];
121
Rusty Russelle1e72962007-10-25 15:02:50 +1000122 /* If you're not the task which owns the Guest, go away. */
Glauber de Oliveira Costa66686c22008-01-07 11:05:34 -0200123 if (current != cpu->tsk)
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700124 return -EPERM;
125
Rusty Russella6bd8e12008-03-28 11:05:53 -0500126 /* If the Guest is already dead, we indicate why */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700127 if (lg->dead) {
128 size_t len;
129
Rusty Russelldde79782007-07-26 10:41:03 -0700130 /* lg->dead either contains an error code, or a string. */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700131 if (IS_ERR(lg->dead))
132 return PTR_ERR(lg->dead);
133
Rusty Russelldde79782007-07-26 10:41:03 -0700134 /* We can only return as much as the buffer they read with. */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700135 len = min(size, strlen(lg->dead)+1);
136 if (copy_to_user(user, lg->dead, len) != 0)
137 return -EFAULT;
138 return len;
139 }
140
Rusty Russella6bd8e12008-03-28 11:05:53 -0500141 /* If we returned from read() last time because the Guest sent I/O,
Rusty Russelldde79782007-07-26 10:41:03 -0700142 * clear the flag. */
Glauber de Oliveira Costa5e232f42008-01-07 11:05:36 -0200143 if (cpu->pending_notify)
144 cpu->pending_notify = 0;
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700145
Rusty Russelldde79782007-07-26 10:41:03 -0700146 /* Run the Guest until something interesting happens. */
Glauber de Oliveira Costad0953d42008-01-07 11:05:25 -0200147 return run_guest(cpu, (unsigned long __user *)user);
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700148}
149
Rusty Russella6bd8e12008-03-28 11:05:53 -0500150/*L:025 This actually initializes a CPU. For the moment, a Guest is only
151 * uniprocessor, so "id" is always 0. */
Glauber de Oliveira Costa4dcc53d2008-01-07 11:05:24 -0200152static int lg_cpu_start(struct lg_cpu *cpu, unsigned id, unsigned long start_ip)
153{
Rusty Russella6bd8e12008-03-28 11:05:53 -0500154 /* We have a limited number the number of CPUs in the lguest struct. */
Rusty Russell24adf122008-05-02 21:50:51 -0500155 if (id >= ARRAY_SIZE(cpu->lg->cpus))
Glauber de Oliveira Costa4dcc53d2008-01-07 11:05:24 -0200156 return -EINVAL;
157
Rusty Russella6bd8e12008-03-28 11:05:53 -0500158 /* Set up this CPU's id, and pointer back to the lguest struct. */
Glauber de Oliveira Costa4dcc53d2008-01-07 11:05:24 -0200159 cpu->id = id;
160 cpu->lg = container_of((cpu - id), struct lguest, cpus[0]);
161 cpu->lg->nr_cpus++;
Rusty Russella6bd8e12008-03-28 11:05:53 -0500162
163 /* Each CPU has a timer it can set. */
Glauber de Oliveira Costaad8d8f32008-01-07 11:05:28 -0200164 init_clockdev(cpu);
Glauber de Oliveira Costa4dcc53d2008-01-07 11:05:24 -0200165
Glauber de Oliveira Costaa53a35a2008-01-07 11:05:32 -0200166 /* We need a complete page for the Guest registers: they are accessible
167 * to the Guest and we can only grant it access to whole pages. */
168 cpu->regs_page = get_zeroed_page(GFP_KERNEL);
169 if (!cpu->regs_page)
170 return -ENOMEM;
171
172 /* We actually put the registers at the bottom of the page. */
173 cpu->regs = (void *)cpu->regs_page + PAGE_SIZE - sizeof(*cpu->regs);
174
175 /* Now we initialize the Guest's registers, handing it the start
176 * address. */
177 lguest_arch_setup_regs(cpu, start_ip);
178
Glauber de Oliveira Costa66686c22008-01-07 11:05:34 -0200179 /* We keep a pointer to the Launcher task (ie. current task) for when
Rusty Russella6bd8e12008-03-28 11:05:53 -0500180 * other Guests want to wake this one (eg. console input). */
Glauber de Oliveira Costa66686c22008-01-07 11:05:34 -0200181 cpu->tsk = current;
182
183 /* We need to keep a pointer to the Launcher's memory map, because if
184 * the Launcher dies we need to clean it up. If we don't keep a
185 * reference, it is destroyed before close() is called. */
186 cpu->mm = get_task_mm(cpu->tsk);
187
Glauber de Oliveira Costaf34f8c52008-01-17 19:13:26 -0200188 /* We remember which CPU's pages this Guest used last, for optimization
189 * when the same Guest runs on the same CPU twice. */
190 cpu->last_pages = NULL;
191
Rusty Russella6bd8e12008-03-28 11:05:53 -0500192 /* No error == success. */
Glauber de Oliveira Costa4dcc53d2008-01-07 11:05:24 -0200193 return 0;
194}
195
Matias Zabaljauregui58a24562008-09-29 01:40:07 -0300196/*L:020 The initialization write supplies 3 pointer sized (32 or 64 bit)
Jes Sorensen511801d2007-10-22 11:03:31 +1000197 * values (in addition to the LHREQ_INITIALIZE value). These are:
Rusty Russelldde79782007-07-26 10:41:03 -0700198 *
Rusty Russell3c6b5bf2007-10-22 11:03:26 +1000199 * base: The start of the Guest-physical memory inside the Launcher memory.
200 *
Rusty Russelldde79782007-07-26 10:41:03 -0700201 * pfnlimit: The highest (Guest-physical) page number the Guest should be
Rusty Russelle1e72962007-10-25 15:02:50 +1000202 * allowed to access. The Guest memory lives inside the Launcher, so it sets
203 * this to ensure the Guest can only reach its own memory.
Rusty Russelldde79782007-07-26 10:41:03 -0700204 *
Rusty Russelldde79782007-07-26 10:41:03 -0700205 * start: The first instruction to execute ("eip" in x86-speak).
Rusty Russelldde79782007-07-26 10:41:03 -0700206 */
Jes Sorensen511801d2007-10-22 11:03:31 +1000207static int initialize(struct file *file, const unsigned long __user *input)
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700208{
Rusty Russelldde79782007-07-26 10:41:03 -0700209 /* "struct lguest" contains everything we (the Host) know about a
210 * Guest. */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700211 struct lguest *lg;
Rusty Russell48245cc2007-10-22 11:03:27 +1000212 int err;
Matias Zabaljauregui58a24562008-09-29 01:40:07 -0300213 unsigned long args[3];
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700214
Rusty Russell48245cc2007-10-22 11:03:27 +1000215 /* We grab the Big Lguest lock, which protects against multiple
216 * simultaneous initializations. */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700217 mutex_lock(&lguest_lock);
Rusty Russelldde79782007-07-26 10:41:03 -0700218 /* You can't initialize twice! Close the device and start again... */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700219 if (file->private_data) {
220 err = -EBUSY;
221 goto unlock;
222 }
223
224 if (copy_from_user(args, input, sizeof(args)) != 0) {
225 err = -EFAULT;
226 goto unlock;
227 }
228
Rusty Russell48245cc2007-10-22 11:03:27 +1000229 lg = kzalloc(sizeof(*lg), GFP_KERNEL);
230 if (!lg) {
231 err = -ENOMEM;
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700232 goto unlock;
233 }
Rusty Russelldde79782007-07-26 10:41:03 -0700234
Rusty Russelldf60aee2009-06-12 22:27:09 -0600235 lg->eventfds = kmalloc(sizeof(*lg->eventfds), GFP_KERNEL);
236 if (!lg->eventfds) {
237 err = -ENOMEM;
238 goto free_lg;
239 }
240 lg->eventfds->num = 0;
241
Rusty Russelldde79782007-07-26 10:41:03 -0700242 /* Populate the easy fields of our "struct lguest" */
Al Viro74dbf712008-03-29 03:08:28 +0000243 lg->mem_base = (void __user *)args[0];
Rusty Russell3c6b5bf2007-10-22 11:03:26 +1000244 lg->pfn_limit = args[1];
Rusty Russelldde79782007-07-26 10:41:03 -0700245
Matias Zabaljauregui58a24562008-09-29 01:40:07 -0300246 /* This is the first cpu (cpu 0) and it will start booting at args[2] */
247 err = lg_cpu_start(&lg->cpus[0], 0, args[2]);
Glauber de Oliveira Costa4dcc53d2008-01-07 11:05:24 -0200248 if (err)
Rusty Russelldf60aee2009-06-12 22:27:09 -0600249 goto free_eventfds;
Glauber de Oliveira Costa4dcc53d2008-01-07 11:05:24 -0200250
Rusty Russelldde79782007-07-26 10:41:03 -0700251 /* Initialize the Guest's shadow page tables, using the toplevel
Rusty Russella6bd8e12008-03-28 11:05:53 -0500252 * address the Launcher gave us. This allocates memory, so can fail. */
Matias Zabaljauregui58a24562008-09-29 01:40:07 -0300253 err = init_guest_pagetable(lg);
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700254 if (err)
255 goto free_regs;
256
Rusty Russelldde79782007-07-26 10:41:03 -0700257 /* We keep our "struct lguest" in the file's private_data. */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700258 file->private_data = lg;
259
260 mutex_unlock(&lguest_lock);
261
Rusty Russelldde79782007-07-26 10:41:03 -0700262 /* And because this is a write() call, we return the length used. */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700263 return sizeof(args);
264
265free_regs:
Glauber de Oliveira Costaa53a35a2008-01-07 11:05:32 -0200266 /* FIXME: This should be in free_vcpu */
267 free_page(lg->cpus[0].regs_page);
Rusty Russelldf60aee2009-06-12 22:27:09 -0600268free_eventfds:
269 kfree(lg->eventfds);
270free_lg:
Adrian Bunk43054412007-11-14 16:59:00 -0800271 kfree(lg);
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700272unlock:
273 mutex_unlock(&lguest_lock);
274 return err;
275}
276
Rusty Russelldde79782007-07-26 10:41:03 -0700277/*L:010 The first operation the Launcher does must be a write. All writes
Rusty Russelle1e72962007-10-25 15:02:50 +1000278 * start with an unsigned long number: for the first write this must be
Rusty Russelldde79782007-07-26 10:41:03 -0700279 * LHREQ_INITIALIZE to set up the Guest. After that the Launcher can use
Rusty Russella6bd8e12008-03-28 11:05:53 -0500280 * writes of other values to send interrupts.
281 *
282 * Note that we overload the "offset" in the /dev/lguest file to indicate what
283 * CPU number we're dealing with. Currently this is always 0, since we only
284 * support uniprocessor Guests, but you can see the beginnings of SMP support
285 * here. */
Jes Sorensen511801d2007-10-22 11:03:31 +1000286static ssize_t write(struct file *file, const char __user *in,
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700287 size_t size, loff_t *off)
288{
Rusty Russella6bd8e12008-03-28 11:05:53 -0500289 /* Once the Guest is initialized, we hold the "struct lguest" in the
Rusty Russelldde79782007-07-26 10:41:03 -0700290 * file private data. */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700291 struct lguest *lg = file->private_data;
Jes Sorensen511801d2007-10-22 11:03:31 +1000292 const unsigned long __user *input = (const unsigned long __user *)in;
293 unsigned long req;
Glauber de Oliveira Costa177e4492008-01-07 11:05:29 -0200294 struct lg_cpu *uninitialized_var(cpu);
Glauber de Oliveira Costa7ea07a12008-01-07 11:05:26 -0200295 unsigned int cpu_id = *off;
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700296
Rusty Russella6bd8e12008-03-28 11:05:53 -0500297 /* The first value tells us what this request is. */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700298 if (get_user(req, input) != 0)
299 return -EFAULT;
Jes Sorensen511801d2007-10-22 11:03:31 +1000300 input++;
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700301
Rusty Russelldde79782007-07-26 10:41:03 -0700302 /* If you haven't initialized, you must do that first. */
Glauber de Oliveira Costa7ea07a12008-01-07 11:05:26 -0200303 if (req != LHREQ_INITIALIZE) {
304 if (!lg || (cpu_id >= lg->nr_cpus))
305 return -EINVAL;
306 cpu = &lg->cpus[cpu_id];
Eugene Teof73d1e62008-02-09 23:53:17 +0800307
308 /* Once the Guest is dead, you can only read() why it died. */
309 if (lg->dead)
310 return -ENOENT;
Glauber de Oliveira Costa7ea07a12008-01-07 11:05:26 -0200311 }
Rusty Russelldde79782007-07-26 10:41:03 -0700312
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700313 switch (req) {
314 case LHREQ_INITIALIZE:
Jes Sorensen511801d2007-10-22 11:03:31 +1000315 return initialize(file, input);
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700316 case LHREQ_IRQ:
Glauber de Oliveira Costa177e4492008-01-07 11:05:29 -0200317 return user_send_irq(cpu, input);
Rusty Russelldf60aee2009-06-12 22:27:09 -0600318 case LHREQ_EVENTFD:
319 return attach_eventfd(lg, input);
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700320 default:
321 return -EINVAL;
322 }
323}
324
Rusty Russelldde79782007-07-26 10:41:03 -0700325/*L:060 The final piece of interface code is the close() routine. It reverses
326 * everything done in initialize(). This is usually called because the
327 * Launcher exited.
328 *
329 * Note that the close routine returns 0 or a negative error number: it can't
330 * really fail, but it can whine. I blame Sun for this wart, and K&R C for
331 * letting them do it. :*/
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700332static int close(struct inode *inode, struct file *file)
333{
334 struct lguest *lg = file->private_data;
Glauber de Oliveira Costaad8d8f32008-01-07 11:05:28 -0200335 unsigned int i;
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700336
Rusty Russelldde79782007-07-26 10:41:03 -0700337 /* If we never successfully initialized, there's nothing to clean up */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700338 if (!lg)
339 return 0;
340
Rusty Russelldde79782007-07-26 10:41:03 -0700341 /* We need the big lock, to protect from inter-guest I/O and other
342 * Launchers initializing guests. */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700343 mutex_lock(&lguest_lock);
Glauber de Oliveira Costa66686c22008-01-07 11:05:34 -0200344
345 /* Free up the shadow page tables for the Guest. */
346 free_guest_pagetable(lg);
347
Glauber de Oliveira Costaa53a35a2008-01-07 11:05:32 -0200348 for (i = 0; i < lg->nr_cpus; i++) {
Glauber de Oliveira Costaad8d8f32008-01-07 11:05:28 -0200349 /* Cancels the hrtimer set via LHCALL_SET_CLOCKEVENT. */
350 hrtimer_cancel(&lg->cpus[i].hrt);
Glauber de Oliveira Costaa53a35a2008-01-07 11:05:32 -0200351 /* We can free up the register page we allocated. */
352 free_page(lg->cpus[i].regs_page);
Glauber de Oliveira Costa66686c22008-01-07 11:05:34 -0200353 /* Now all the memory cleanups are done, it's safe to release
354 * the Launcher's memory management structure. */
355 mmput(lg->cpus[i].mm);
Glauber de Oliveira Costaa53a35a2008-01-07 11:05:32 -0200356 }
Rusty Russelldf60aee2009-06-12 22:27:09 -0600357
358 /* Release any eventfds they registered. */
359 for (i = 0; i < lg->eventfds->num; i++)
Davide Libenzi13389012009-06-30 11:41:11 -0700360 eventfd_ctx_put(lg->eventfds->map[i].event);
Rusty Russelldf60aee2009-06-12 22:27:09 -0600361 kfree(lg->eventfds);
362
Rusty Russelldde79782007-07-26 10:41:03 -0700363 /* If lg->dead doesn't contain an error code it will be NULL or a
364 * kmalloc()ed string, either of which is ok to hand to kfree(). */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700365 if (!IS_ERR(lg->dead))
366 kfree(lg->dead);
Mark Wallis05dfdbb2009-01-26 17:32:35 +1100367 /* Free the memory allocated to the lguest_struct */
368 kfree(lg);
Rusty Russelldde79782007-07-26 10:41:03 -0700369 /* Release lock and exit. */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700370 mutex_unlock(&lguest_lock);
Rusty Russelldde79782007-07-26 10:41:03 -0700371
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700372 return 0;
373}
374
Rusty Russelldde79782007-07-26 10:41:03 -0700375/*L:000
376 * Welcome to our journey through the Launcher!
377 *
378 * The Launcher is the Host userspace program which sets up, runs and services
379 * the Guest. In fact, many comments in the Drivers which refer to "the Host"
380 * doing things are inaccurate: the Launcher does all the device handling for
Rusty Russelle1e72962007-10-25 15:02:50 +1000381 * the Guest, but the Guest can't know that.
Rusty Russelldde79782007-07-26 10:41:03 -0700382 *
383 * Just to confuse you: to the Host kernel, the Launcher *is* the Guest and we
384 * shall see more of that later.
385 *
386 * We begin our understanding with the Host kernel interface which the Launcher
387 * uses: reading and writing a character device called /dev/lguest. All the
388 * work happens in the read(), write() and close() routines: */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700389static struct file_operations lguest_fops = {
390 .owner = THIS_MODULE,
391 .release = close,
392 .write = write,
393 .read = read,
394};
Rusty Russelldde79782007-07-26 10:41:03 -0700395
396/* This is a textbook example of a "misc" character device. Populate a "struct
397 * miscdevice" and register it with misc_register(). */
Rusty Russelld7e28ff2007-07-19 01:49:23 -0700398static struct miscdevice lguest_dev = {
399 .minor = MISC_DYNAMIC_MINOR,
400 .name = "lguest",
401 .fops = &lguest_fops,
402};
403
404int __init lguest_device_init(void)
405{
406 return misc_register(&lguest_dev);
407}
408
409void __exit lguest_device_remove(void)
410{
411 misc_deregister(&lguest_dev);
412}