2011-07-22 05:09:50 +00:00
|
|
|
/*P:200 This contains all the /dev/lguest code, whereby the userspace
|
|
|
|
* launcher controls and communicates with the Guest. For example,
|
|
|
|
* the first write will tell us the Guest's memory layout and entry
|
|
|
|
* point. A read will run the Guest until something happens, such as
|
|
|
|
* a signal or the Guest doing a NOTIFY out to the Launcher. There is
|
|
|
|
* also a way for the Launcher to attach eventfds to particular NOTIFY
|
|
|
|
* values instead of returning from the read() call.
|
2009-07-30 22:03:45 +00:00
|
|
|
:*/
|
2007-07-19 08:49:23 +00:00
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <linux/miscdevice.h>
|
|
|
|
#include <linux/fs.h>
|
2008-01-19 01:59:07 +00:00
|
|
|
#include <linux/sched.h>
|
2009-06-13 04:27:09 +00:00
|
|
|
#include <linux/eventfd.h>
|
|
|
|
#include <linux/file.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2011-07-21 17:03:20 +00:00
|
|
|
#include <linux/export.h>
|
2007-07-19 08:49:23 +00:00
|
|
|
#include "lg.h"
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*L:056
|
|
|
|
* Before we move on, let's jump ahead and look at what the kernel does when
|
|
|
|
* it needs to look up the eventfds. That will complete our picture of how we
|
|
|
|
* use RCU.
|
|
|
|
*
|
|
|
|
* The notification value is in cpu->pending_notify: we return true if it went
|
|
|
|
* to an eventfd.
|
|
|
|
*/
|
2009-06-13 04:27:09 +00:00
|
|
|
bool send_notify_to_eventfd(struct lg_cpu *cpu)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
struct lg_eventfd_map *map;
|
|
|
|
|
2015-02-11 04:45:09 +00:00
|
|
|
/* We only connect LHCALL_NOTIFY to event fds, not other traps. */
|
|
|
|
if (cpu->pending.trap != LGUEST_TRAP_ENTRY)
|
|
|
|
return false;
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* This "rcu_read_lock()" helps track when someone is still looking at
|
|
|
|
* the (RCU-using) eventfds array. It's not actually a lock at all;
|
|
|
|
* indeed it's a noop in many configurations. (You didn't expect me to
|
|
|
|
* explain all the RCU secrets here, did you?)
|
|
|
|
*/
|
2009-06-13 04:27:09 +00:00
|
|
|
rcu_read_lock();
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* rcu_dereference is the counter-side of rcu_assign_pointer(); it
|
|
|
|
* makes sure we don't access the memory pointed to by
|
|
|
|
* cpu->lg->eventfds before cpu->lg->eventfds is set. Sounds crazy,
|
|
|
|
* but Alpha allows this! Paul McKenney points out that a really
|
|
|
|
* aggressive compiler could have the same effect:
|
|
|
|
* http://lists.ozlabs.org/pipermail/lguest/2009-July/001560.html
|
|
|
|
*
|
|
|
|
* So play safe, use rcu_dereference to get the rcu-protected pointer:
|
|
|
|
*/
|
2009-06-13 04:27:09 +00:00
|
|
|
map = rcu_dereference(cpu->lg->eventfds);
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* Simple array search: even if they add an eventfd while we do this,
|
|
|
|
* we'll continue to use the old array and just won't see the new one.
|
|
|
|
*/
|
2009-06-13 04:27:09 +00:00
|
|
|
for (i = 0; i < map->num; i++) {
|
2015-02-11 04:45:09 +00:00
|
|
|
if (map->map[i].addr == cpu->pending.addr) {
|
2009-06-13 04:27:09 +00:00
|
|
|
eventfd_signal(map->map[i].event, 1);
|
2015-02-11 04:45:09 +00:00
|
|
|
cpu->pending.trap = 0;
|
2009-06-13 04:27:09 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-07-30 22:03:45 +00:00
|
|
|
/* We're done with the rcu-protected variable cpu->lg->eventfds. */
|
2009-06-13 04:27:09 +00:00
|
|
|
rcu_read_unlock();
|
2009-07-30 22:03:45 +00:00
|
|
|
|
|
|
|
/* If we cleared the notification, it's because we found a match. */
|
2015-02-11 04:45:09 +00:00
|
|
|
return cpu->pending.trap == 0;
|
2009-06-13 04:27:09 +00:00
|
|
|
}
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*L:055
|
|
|
|
* One of the more tricksy tricks in the Linux Kernel is a technique called
|
|
|
|
* Read Copy Update. Since one point of lguest is to teach lguest journeyers
|
|
|
|
* about kernel coding, I use it here. (In case you're curious, other purposes
|
|
|
|
* include learning about virtualization and instilling a deep appreciation for
|
|
|
|
* simplicity and puppies).
|
|
|
|
*
|
|
|
|
* We keep a simple array which maps LHCALL_NOTIFY values to eventfds, but we
|
|
|
|
* add new eventfds without ever blocking readers from accessing the array.
|
|
|
|
* The current Launcher only does this during boot, so that never happens. But
|
|
|
|
* Read Copy Update is cool, and adding a lock risks damaging even more puppies
|
|
|
|
* than this code does.
|
|
|
|
*
|
|
|
|
* We allocate a brand new one-larger array, copy the old one and add our new
|
|
|
|
* element. Then we make the lg eventfd pointer point to the new array.
|
|
|
|
* That's the easy part: now we need to free the old one, but we need to make
|
|
|
|
* sure no slow CPU somewhere is still looking at it. That's what
|
|
|
|
* synchronize_rcu does for us: waits until every CPU has indicated that it has
|
|
|
|
* moved on to know it's no longer using the old one.
|
|
|
|
*
|
|
|
|
* If that's unclear, see http://en.wikipedia.org/wiki/Read-copy-update.
|
|
|
|
*/
|
2009-06-13 04:27:09 +00:00
|
|
|
static int add_eventfd(struct lguest *lg, unsigned long addr, int fd)
|
|
|
|
{
|
|
|
|
struct lg_eventfd_map *new, *old = lg->eventfds;
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* We don't allow notifications on value 0 anyway (pending_notify of
|
|
|
|
* 0 means "nothing pending").
|
|
|
|
*/
|
2009-06-13 04:27:09 +00:00
|
|
|
if (!addr)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* Replace the old array with the new one, carefully: others can
|
|
|
|
* be accessing it at the same time.
|
|
|
|
*/
|
2009-06-13 04:27:09 +00:00
|
|
|
new = kmalloc(sizeof(*new) + sizeof(new->map[0]) * (old->num + 1),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!new)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* First make identical copy. */
|
|
|
|
memcpy(new->map, old->map, sizeof(old->map[0]) * old->num);
|
|
|
|
new->num = old->num;
|
|
|
|
|
|
|
|
/* Now append new entry. */
|
|
|
|
new->map[new->num].addr = addr;
|
2009-06-30 18:41:11 +00:00
|
|
|
new->map[new->num].event = eventfd_ctx_fdget(fd);
|
2009-06-13 04:27:09 +00:00
|
|
|
if (IS_ERR(new->map[new->num].event)) {
|
2009-07-19 11:46:09 +00:00
|
|
|
int err = PTR_ERR(new->map[new->num].event);
|
2009-06-13 04:27:09 +00:00
|
|
|
kfree(new);
|
2009-07-19 11:46:09 +00:00
|
|
|
return err;
|
2009-06-13 04:27:09 +00:00
|
|
|
}
|
|
|
|
new->num++;
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* Now put new one in place: rcu_assign_pointer() is a fancy way of
|
|
|
|
* doing "lg->eventfds = new", but it uses memory barriers to make
|
|
|
|
* absolutely sure that the contents of "new" written above is nailed
|
|
|
|
* down before we actually do the assignment.
|
|
|
|
*
|
|
|
|
* We have to think about these kinds of things when we're operating on
|
|
|
|
* live data without locks.
|
|
|
|
*/
|
2009-06-13 04:27:09 +00:00
|
|
|
rcu_assign_pointer(lg->eventfds, new);
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
2011-03-31 01:57:33 +00:00
|
|
|
* We're not in a big hurry. Wait until no one's looking at old
|
2009-07-30 22:03:45 +00:00
|
|
|
* version, then free it.
|
2009-07-30 22:03:45 +00:00
|
|
|
*/
|
2009-06-13 04:27:09 +00:00
|
|
|
synchronize_rcu();
|
|
|
|
kfree(old);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*L:052
|
|
|
|
* Receiving notifications from the Guest is usually done by attaching a
|
|
|
|
* particular LHCALL_NOTIFY value to an event filedescriptor. The eventfd will
|
|
|
|
* become readable when the Guest does an LHCALL_NOTIFY with that value.
|
|
|
|
*
|
|
|
|
* This is really convenient for processing each virtqueue in a separate
|
|
|
|
* thread.
|
|
|
|
*/
|
2009-06-13 04:27:09 +00:00
|
|
|
static int attach_eventfd(struct lguest *lg, const unsigned long __user *input)
|
|
|
|
{
|
|
|
|
unsigned long addr, fd;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (get_user(addr, input) != 0)
|
|
|
|
return -EFAULT;
|
|
|
|
input++;
|
|
|
|
if (get_user(fd, input) != 0)
|
|
|
|
return -EFAULT;
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* Just make sure two callers don't add eventfds at once. We really
|
|
|
|
* only need to lock against callers adding to the same Guest, so using
|
|
|
|
* the Big Lguest Lock is overkill. But this is setup, not a fast path.
|
|
|
|
*/
|
2009-06-13 04:27:09 +00:00
|
|
|
mutex_lock(&lguest_lock);
|
|
|
|
err = add_eventfd(lg, addr, fd);
|
|
|
|
mutex_unlock(&lguest_lock);
|
|
|
|
|
2009-07-19 11:46:09 +00:00
|
|
|
return err;
|
2009-06-13 04:27:09 +00:00
|
|
|
}
|
|
|
|
|
2015-02-11 04:45:09 +00:00
|
|
|
/* The Launcher can get the registers, and also set some of them. */
|
|
|
|
static int getreg_setup(struct lg_cpu *cpu, const unsigned long __user *input)
|
|
|
|
{
|
|
|
|
unsigned long which;
|
|
|
|
|
|
|
|
/* We re-use the ptrace structure to specify which register to read. */
|
|
|
|
if (get_user(which, input) != 0)
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We set up the cpu register pointer, and their next read will
|
|
|
|
* actually get the value (instead of running the guest).
|
|
|
|
*
|
|
|
|
* The last argument 'true' says we can access any register.
|
|
|
|
*/
|
|
|
|
cpu->reg_read = lguest_arch_regptr(cpu, which, true);
|
|
|
|
if (!cpu->reg_read)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
/* And because this is a write() call, we return the length used. */
|
|
|
|
return sizeof(unsigned long) * 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int setreg(struct lg_cpu *cpu, const unsigned long __user *input)
|
|
|
|
{
|
|
|
|
unsigned long which, value, *reg;
|
|
|
|
|
|
|
|
/* We re-use the ptrace structure to specify which register to read. */
|
|
|
|
if (get_user(which, input) != 0)
|
|
|
|
return -EFAULT;
|
|
|
|
input++;
|
|
|
|
if (get_user(value, input) != 0)
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
/* The last argument 'false' means we can't access all registers. */
|
|
|
|
reg = lguest_arch_regptr(cpu, which, false);
|
|
|
|
if (!reg)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
*reg = value;
|
|
|
|
|
|
|
|
/* And because this is a write() call, we return the length used. */
|
|
|
|
return sizeof(unsigned long) * 3;
|
|
|
|
}
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*L:050
|
|
|
|
* Sending an interrupt is done by writing LHREQ_IRQ and an interrupt
|
|
|
|
* number to /dev/lguest.
|
|
|
|
*/
|
2008-01-07 13:05:29 +00:00
|
|
|
static int user_send_irq(struct lg_cpu *cpu, const unsigned long __user *input)
|
2007-07-19 08:49:23 +00:00
|
|
|
{
|
2007-10-22 01:03:31 +00:00
|
|
|
unsigned long irq;
|
2007-07-19 08:49:23 +00:00
|
|
|
|
|
|
|
if (get_user(irq, input) != 0)
|
|
|
|
return -EFAULT;
|
|
|
|
if (irq >= LGUEST_IRQS)
|
|
|
|
return -EINVAL;
|
2009-06-13 04:27:08 +00:00
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* Next time the Guest runs, the core code will see if it can deliver
|
|
|
|
* this interrupt.
|
|
|
|
*/
|
2009-06-13 04:27:08 +00:00
|
|
|
set_interrupt(cpu, irq);
|
2007-07-19 08:49:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-02-11 04:45:09 +00:00
|
|
|
/*L:053
|
|
|
|
* Deliver a trap: this is used by the Launcher if it can't emulate
|
|
|
|
* an instruction.
|
|
|
|
*/
|
|
|
|
static int trap(struct lg_cpu *cpu, const unsigned long __user *input)
|
|
|
|
{
|
|
|
|
unsigned long trapnum;
|
|
|
|
|
|
|
|
if (get_user(trapnum, input) != 0)
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
if (!deliver_trap(cpu, trapnum))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*L:040
|
|
|
|
* Once our Guest is initialized, the Launcher makes it run by reading
|
|
|
|
* from /dev/lguest.
|
|
|
|
*/
|
2007-07-19 08:49:23 +00:00
|
|
|
static ssize_t read(struct file *file, char __user *user, size_t size,loff_t*o)
|
|
|
|
{
|
|
|
|
struct lguest *lg = file->private_data;
|
2008-01-07 13:05:25 +00:00
|
|
|
struct lg_cpu *cpu;
|
|
|
|
unsigned int cpu_id = *o;
|
2007-07-19 08:49:23 +00:00
|
|
|
|
2007-07-26 17:41:03 +00:00
|
|
|
/* You must write LHREQ_INITIALIZE first! */
|
2007-07-19 08:49:23 +00:00
|
|
|
if (!lg)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-01-07 13:05:25 +00:00
|
|
|
/* Watch out for arbitrary vcpu indexes! */
|
|
|
|
if (cpu_id >= lg->nr_cpus)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
cpu = &lg->cpus[cpu_id];
|
|
|
|
|
2007-10-25 05:02:50 +00:00
|
|
|
/* If you're not the task which owns the Guest, go away. */
|
2008-01-07 13:05:34 +00:00
|
|
|
if (current != cpu->tsk)
|
2007-07-19 08:49:23 +00:00
|
|
|
return -EPERM;
|
|
|
|
|
2008-03-28 16:05:53 +00:00
|
|
|
/* If the Guest is already dead, we indicate why */
|
2007-07-19 08:49:23 +00:00
|
|
|
if (lg->dead) {
|
|
|
|
size_t len;
|
|
|
|
|
2007-07-26 17:41:03 +00:00
|
|
|
/* lg->dead either contains an error code, or a string. */
|
2007-07-19 08:49:23 +00:00
|
|
|
if (IS_ERR(lg->dead))
|
|
|
|
return PTR_ERR(lg->dead);
|
|
|
|
|
2007-07-26 17:41:03 +00:00
|
|
|
/* We can only return as much as the buffer they read with. */
|
2007-07-19 08:49:23 +00:00
|
|
|
len = min(size, strlen(lg->dead)+1);
|
|
|
|
if (copy_to_user(user, lg->dead, len) != 0)
|
|
|
|
return -EFAULT;
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* If we returned from read() last time because the Guest sent I/O,
|
|
|
|
* clear the flag.
|
|
|
|
*/
|
2015-02-11 04:45:09 +00:00
|
|
|
if (cpu->pending.trap)
|
|
|
|
cpu->pending.trap = 0;
|
2007-07-19 08:49:23 +00:00
|
|
|
|
2007-07-26 17:41:03 +00:00
|
|
|
/* Run the Guest until something interesting happens. */
|
2008-01-07 13:05:25 +00:00
|
|
|
return run_guest(cpu, (unsigned long __user *)user);
|
2007-07-19 08:49:23 +00:00
|
|
|
}
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*L:025
|
|
|
|
* This actually initializes a CPU. For the moment, a Guest is only
|
|
|
|
* uniprocessor, so "id" is always 0.
|
|
|
|
*/
|
2008-01-07 13:05:24 +00:00
|
|
|
static int lg_cpu_start(struct lg_cpu *cpu, unsigned id, unsigned long start_ip)
|
|
|
|
{
|
2013-04-29 23:53:09 +00:00
|
|
|
/* We have a limited number of CPUs in the lguest struct. */
|
2008-05-03 02:50:51 +00:00
|
|
|
if (id >= ARRAY_SIZE(cpu->lg->cpus))
|
2008-01-07 13:05:24 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2008-03-28 16:05:53 +00:00
|
|
|
/* Set up this CPU's id, and pointer back to the lguest struct. */
|
2008-01-07 13:05:24 +00:00
|
|
|
cpu->id = id;
|
2013-04-29 23:53:09 +00:00
|
|
|
cpu->lg = container_of(cpu, struct lguest, cpus[id]);
|
2008-01-07 13:05:24 +00:00
|
|
|
cpu->lg->nr_cpus++;
|
2008-03-28 16:05:53 +00:00
|
|
|
|
|
|
|
/* Each CPU has a timer it can set. */
|
2008-01-07 13:05:28 +00:00
|
|
|
init_clockdev(cpu);
|
2008-01-07 13:05:24 +00:00
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* We need a complete page for the Guest registers: they are accessible
|
|
|
|
* to the Guest and we can only grant it access to whole pages.
|
|
|
|
*/
|
2008-01-07 13:05:32 +00:00
|
|
|
cpu->regs_page = get_zeroed_page(GFP_KERNEL);
|
|
|
|
if (!cpu->regs_page)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2013-04-29 23:53:09 +00:00
|
|
|
/* We actually put the registers at the end of the page. */
|
2008-01-07 13:05:32 +00:00
|
|
|
cpu->regs = (void *)cpu->regs_page + PAGE_SIZE - sizeof(*cpu->regs);
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* Now we initialize the Guest's registers, handing it the start
|
|
|
|
* address.
|
|
|
|
*/
|
2008-01-07 13:05:32 +00:00
|
|
|
lguest_arch_setup_regs(cpu, start_ip);
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* We keep a pointer to the Launcher task (ie. current task) for when
|
|
|
|
* other Guests want to wake this one (eg. console input).
|
|
|
|
*/
|
2008-01-07 13:05:34 +00:00
|
|
|
cpu->tsk = current;
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* We need to keep a pointer to the Launcher's memory map, because if
|
2008-01-07 13:05:34 +00:00
|
|
|
* the Launcher dies we need to clean it up. If we don't keep a
|
2009-07-30 22:03:45 +00:00
|
|
|
* reference, it is destroyed before close() is called.
|
|
|
|
*/
|
2008-01-07 13:05:34 +00:00
|
|
|
cpu->mm = get_task_mm(cpu->tsk);
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* We remember which CPU's pages this Guest used last, for optimization
|
|
|
|
* when the same Guest runs on the same CPU twice.
|
|
|
|
*/
|
2008-01-17 21:13:26 +00:00
|
|
|
cpu->last_pages = NULL;
|
|
|
|
|
2008-03-28 16:05:53 +00:00
|
|
|
/* No error == success. */
|
2008-01-07 13:05:24 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*L:020
|
|
|
|
* The initialization write supplies 3 pointer sized (32 or 64 bit) values (in
|
|
|
|
* addition to the LHREQ_INITIALIZE value). These are:
|
2007-07-26 17:41:03 +00:00
|
|
|
*
|
2007-10-22 01:03:26 +00:00
|
|
|
* base: The start of the Guest-physical memory inside the Launcher memory.
|
|
|
|
*
|
2007-07-26 17:41:03 +00:00
|
|
|
* pfnlimit: The highest (Guest-physical) page number the Guest should be
|
2007-10-25 05:02:50 +00:00
|
|
|
* allowed to access. The Guest memory lives inside the Launcher, so it sets
|
|
|
|
* this to ensure the Guest can only reach its own memory.
|
2007-07-26 17:41:03 +00:00
|
|
|
*
|
|
|
|
* start: The first instruction to execute ("eip" in x86-speak).
|
|
|
|
*/
|
2007-10-22 01:03:31 +00:00
|
|
|
static int initialize(struct file *file, const unsigned long __user *input)
|
2007-07-19 08:49:23 +00:00
|
|
|
{
|
2009-07-30 22:03:45 +00:00
|
|
|
/* "struct lguest" contains all we (the Host) know about a Guest. */
|
2007-07-19 08:49:23 +00:00
|
|
|
struct lguest *lg;
|
2007-10-22 01:03:27 +00:00
|
|
|
int err;
|
2008-09-29 04:40:07 +00:00
|
|
|
unsigned long args[3];
|
2007-07-19 08:49:23 +00:00
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* We grab the Big Lguest lock, which protects against multiple
|
|
|
|
* simultaneous initializations.
|
|
|
|
*/
|
2007-07-19 08:49:23 +00:00
|
|
|
mutex_lock(&lguest_lock);
|
2007-07-26 17:41:03 +00:00
|
|
|
/* You can't initialize twice! Close the device and start again... */
|
2007-07-19 08:49:23 +00:00
|
|
|
if (file->private_data) {
|
|
|
|
err = -EBUSY;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (copy_from_user(args, input, sizeof(args)) != 0) {
|
|
|
|
err = -EFAULT;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
2007-10-22 01:03:27 +00:00
|
|
|
lg = kzalloc(sizeof(*lg), GFP_KERNEL);
|
|
|
|
if (!lg) {
|
|
|
|
err = -ENOMEM;
|
2007-07-19 08:49:23 +00:00
|
|
|
goto unlock;
|
|
|
|
}
|
2007-07-26 17:41:03 +00:00
|
|
|
|
2009-06-13 04:27:09 +00:00
|
|
|
lg->eventfds = kmalloc(sizeof(*lg->eventfds), GFP_KERNEL);
|
|
|
|
if (!lg->eventfds) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free_lg;
|
|
|
|
}
|
|
|
|
lg->eventfds->num = 0;
|
|
|
|
|
2007-07-26 17:41:03 +00:00
|
|
|
/* Populate the easy fields of our "struct lguest" */
|
2008-03-29 03:08:28 +00:00
|
|
|
lg->mem_base = (void __user *)args[0];
|
2007-10-22 01:03:26 +00:00
|
|
|
lg->pfn_limit = args[1];
|
2007-07-26 17:41:03 +00:00
|
|
|
|
2008-09-29 04:40:07 +00:00
|
|
|
/* This is the first cpu (cpu 0) and it will start booting at args[2] */
|
|
|
|
err = lg_cpu_start(&lg->cpus[0], 0, args[2]);
|
2008-01-07 13:05:24 +00:00
|
|
|
if (err)
|
2009-06-13 04:27:09 +00:00
|
|
|
goto free_eventfds;
|
2008-01-07 13:05:24 +00:00
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
2011-07-22 05:09:50 +00:00
|
|
|
* Initialize the Guest's shadow page tables. This allocates
|
|
|
|
* memory, so can fail.
|
2009-07-30 22:03:45 +00:00
|
|
|
*/
|
2008-09-29 04:40:07 +00:00
|
|
|
err = init_guest_pagetable(lg);
|
2007-07-19 08:49:23 +00:00
|
|
|
if (err)
|
|
|
|
goto free_regs;
|
|
|
|
|
2007-07-26 17:41:03 +00:00
|
|
|
/* We keep our "struct lguest" in the file's private_data. */
|
2007-07-19 08:49:23 +00:00
|
|
|
file->private_data = lg;
|
|
|
|
|
|
|
|
mutex_unlock(&lguest_lock);
|
|
|
|
|
2007-07-26 17:41:03 +00:00
|
|
|
/* And because this is a write() call, we return the length used. */
|
2007-07-19 08:49:23 +00:00
|
|
|
return sizeof(args);
|
|
|
|
|
|
|
|
free_regs:
|
2008-01-07 13:05:32 +00:00
|
|
|
/* FIXME: This should be in free_vcpu */
|
|
|
|
free_page(lg->cpus[0].regs_page);
|
2009-06-13 04:27:09 +00:00
|
|
|
free_eventfds:
|
|
|
|
kfree(lg->eventfds);
|
|
|
|
free_lg:
|
2007-11-15 00:59:00 +00:00
|
|
|
kfree(lg);
|
2007-07-19 08:49:23 +00:00
|
|
|
unlock:
|
|
|
|
mutex_unlock(&lguest_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*L:010
|
|
|
|
* The first operation the Launcher does must be a write. All writes
|
2007-10-25 05:02:50 +00:00
|
|
|
* start with an unsigned long number: for the first write this must be
|
2007-07-26 17:41:03 +00:00
|
|
|
* LHREQ_INITIALIZE to set up the Guest. After that the Launcher can use
|
2009-07-30 22:03:45 +00:00
|
|
|
* writes of other values to send interrupts or set up receipt of notifications.
|
2008-03-28 16:05:53 +00:00
|
|
|
*
|
|
|
|
* Note that we overload the "offset" in the /dev/lguest file to indicate what
|
2009-07-30 22:03:45 +00:00
|
|
|
* CPU number we're dealing with. Currently this is always 0 since we only
|
2008-03-28 16:05:53 +00:00
|
|
|
* support uniprocessor Guests, but you can see the beginnings of SMP support
|
2009-07-30 22:03:45 +00:00
|
|
|
* here.
|
|
|
|
*/
|
2007-10-22 01:03:31 +00:00
|
|
|
static ssize_t write(struct file *file, const char __user *in,
|
2007-07-19 08:49:23 +00:00
|
|
|
size_t size, loff_t *off)
|
|
|
|
{
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* Once the Guest is initialized, we hold the "struct lguest" in the
|
|
|
|
* file private data.
|
|
|
|
*/
|
2007-07-19 08:49:23 +00:00
|
|
|
struct lguest *lg = file->private_data;
|
2007-10-22 01:03:31 +00:00
|
|
|
const unsigned long __user *input = (const unsigned long __user *)in;
|
|
|
|
unsigned long req;
|
2008-01-07 13:05:29 +00:00
|
|
|
struct lg_cpu *uninitialized_var(cpu);
|
2008-01-07 13:05:26 +00:00
|
|
|
unsigned int cpu_id = *off;
|
2007-07-19 08:49:23 +00:00
|
|
|
|
2008-03-28 16:05:53 +00:00
|
|
|
/* The first value tells us what this request is. */
|
2007-07-19 08:49:23 +00:00
|
|
|
if (get_user(req, input) != 0)
|
|
|
|
return -EFAULT;
|
2007-10-22 01:03:31 +00:00
|
|
|
input++;
|
2007-07-19 08:49:23 +00:00
|
|
|
|
2007-07-26 17:41:03 +00:00
|
|
|
/* If you haven't initialized, you must do that first. */
|
2008-01-07 13:05:26 +00:00
|
|
|
if (req != LHREQ_INITIALIZE) {
|
|
|
|
if (!lg || (cpu_id >= lg->nr_cpus))
|
|
|
|
return -EINVAL;
|
|
|
|
cpu = &lg->cpus[cpu_id];
|
2007-07-26 17:41:03 +00:00
|
|
|
|
2008-02-09 15:53:17 +00:00
|
|
|
/* Once the Guest is dead, you can only read() why it died. */
|
|
|
|
if (lg->dead)
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2007-07-19 08:49:23 +00:00
|
|
|
|
|
|
|
switch (req) {
|
|
|
|
case LHREQ_INITIALIZE:
|
2007-10-22 01:03:31 +00:00
|
|
|
return initialize(file, input);
|
2007-07-19 08:49:23 +00:00
|
|
|
case LHREQ_IRQ:
|
2008-01-07 13:05:29 +00:00
|
|
|
return user_send_irq(cpu, input);
|
2009-06-13 04:27:09 +00:00
|
|
|
case LHREQ_EVENTFD:
|
|
|
|
return attach_eventfd(lg, input);
|
2015-02-11 04:45:09 +00:00
|
|
|
case LHREQ_GETREG:
|
|
|
|
return getreg_setup(cpu, input);
|
|
|
|
case LHREQ_SETREG:
|
|
|
|
return setreg(cpu, input);
|
2015-02-11 04:45:09 +00:00
|
|
|
case LHREQ_TRAP:
|
|
|
|
return trap(cpu, input);
|
2007-07-19 08:49:23 +00:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*L:060
|
|
|
|
* The final piece of interface code is the close() routine. It reverses
|
2007-07-26 17:41:03 +00:00
|
|
|
* everything done in initialize(). This is usually called because the
|
|
|
|
* Launcher exited.
|
|
|
|
*
|
|
|
|
* Note that the close routine returns 0 or a negative error number: it can't
|
|
|
|
* really fail, but it can whine. I blame Sun for this wart, and K&R C for
|
2009-07-30 22:03:45 +00:00
|
|
|
* letting them do it.
|
|
|
|
:*/
|
2007-07-19 08:49:23 +00:00
|
|
|
static int close(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct lguest *lg = file->private_data;
|
2008-01-07 13:05:28 +00:00
|
|
|
unsigned int i;
|
2007-07-19 08:49:23 +00:00
|
|
|
|
2007-07-26 17:41:03 +00:00
|
|
|
/* If we never successfully initialized, there's nothing to clean up */
|
2007-07-19 08:49:23 +00:00
|
|
|
if (!lg)
|
|
|
|
return 0;
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* We need the big lock, to protect from inter-guest I/O and other
|
|
|
|
* Launchers initializing guests.
|
|
|
|
*/
|
2007-07-19 08:49:23 +00:00
|
|
|
mutex_lock(&lguest_lock);
|
2008-01-07 13:05:34 +00:00
|
|
|
|
|
|
|
/* Free up the shadow page tables for the Guest. */
|
|
|
|
free_guest_pagetable(lg);
|
|
|
|
|
2008-01-07 13:05:32 +00:00
|
|
|
for (i = 0; i < lg->nr_cpus; i++) {
|
2008-01-07 13:05:28 +00:00
|
|
|
/* Cancels the hrtimer set via LHCALL_SET_CLOCKEVENT. */
|
|
|
|
hrtimer_cancel(&lg->cpus[i].hrt);
|
2008-01-07 13:05:32 +00:00
|
|
|
/* We can free up the register page we allocated. */
|
|
|
|
free_page(lg->cpus[i].regs_page);
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* Now all the memory cleanups are done, it's safe to release
|
|
|
|
* the Launcher's memory management structure.
|
|
|
|
*/
|
2008-01-07 13:05:34 +00:00
|
|
|
mmput(lg->cpus[i].mm);
|
2008-01-07 13:05:32 +00:00
|
|
|
}
|
2009-06-13 04:27:09 +00:00
|
|
|
|
|
|
|
/* Release any eventfds they registered. */
|
|
|
|
for (i = 0; i < lg->eventfds->num; i++)
|
2009-06-30 18:41:11 +00:00
|
|
|
eventfd_ctx_put(lg->eventfds->map[i].event);
|
2009-06-13 04:27:09 +00:00
|
|
|
kfree(lg->eventfds);
|
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* If lg->dead doesn't contain an error code it will be NULL or a
|
|
|
|
* kmalloc()ed string, either of which is ok to hand to kfree().
|
|
|
|
*/
|
2007-07-19 08:49:23 +00:00
|
|
|
if (!IS_ERR(lg->dead))
|
|
|
|
kfree(lg->dead);
|
2009-01-26 06:32:35 +00:00
|
|
|
/* Free the memory allocated to the lguest_struct */
|
|
|
|
kfree(lg);
|
2007-07-26 17:41:03 +00:00
|
|
|
/* Release lock and exit. */
|
2007-07-19 08:49:23 +00:00
|
|
|
mutex_unlock(&lguest_lock);
|
2007-07-26 17:41:03 +00:00
|
|
|
|
2007-07-19 08:49:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-26 17:41:03 +00:00
|
|
|
/*L:000
|
|
|
|
* Welcome to our journey through the Launcher!
|
|
|
|
*
|
|
|
|
* The Launcher is the Host userspace program which sets up, runs and services
|
|
|
|
* the Guest. In fact, many comments in the Drivers which refer to "the Host"
|
|
|
|
* doing things are inaccurate: the Launcher does all the device handling for
|
2007-10-25 05:02:50 +00:00
|
|
|
* the Guest, but the Guest can't know that.
|
2007-07-26 17:41:03 +00:00
|
|
|
*
|
|
|
|
* Just to confuse you: to the Host kernel, the Launcher *is* the Guest and we
|
|
|
|
* shall see more of that later.
|
|
|
|
*
|
|
|
|
* We begin our understanding with the Host kernel interface which the Launcher
|
|
|
|
* uses: reading and writing a character device called /dev/lguest. All the
|
2009-07-30 22:03:45 +00:00
|
|
|
* work happens in the read(), write() and close() routines:
|
|
|
|
*/
|
2009-10-01 22:43:56 +00:00
|
|
|
static const struct file_operations lguest_fops = {
|
2007-07-19 08:49:23 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.release = close,
|
|
|
|
.write = write,
|
|
|
|
.read = read,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-15 16:52:59 +00:00
|
|
|
.llseek = default_llseek,
|
2007-07-19 08:49:23 +00:00
|
|
|
};
|
2011-07-22 05:09:50 +00:00
|
|
|
/*:*/
|
2007-07-26 17:41:03 +00:00
|
|
|
|
2009-07-30 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* This is a textbook example of a "misc" character device. Populate a "struct
|
|
|
|
* miscdevice" and register it with misc_register().
|
|
|
|
*/
|
2007-07-19 08:49:23 +00:00
|
|
|
static struct miscdevice lguest_dev = {
|
|
|
|
.minor = MISC_DYNAMIC_MINOR,
|
|
|
|
.name = "lguest",
|
|
|
|
.fops = &lguest_fops,
|
|
|
|
};
|
|
|
|
|
|
|
|
int __init lguest_device_init(void)
|
|
|
|
{
|
|
|
|
return misc_register(&lguest_dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
void __exit lguest_device_remove(void)
|
|
|
|
{
|
|
|
|
misc_deregister(&lguest_dev);
|
|
|
|
}
|