2005-05-28 15:51:58 -07:00
|
|
|
/* Copyright (C) 2005 Jeff Dike <jdike@addtoit.com> */
|
|
|
|
/* Much of this ripped from drivers/char/hw_random.c, see there for other
|
|
|
|
* copyright.
|
|
|
|
*
|
|
|
|
* This software may be used and distributed according to the terms
|
|
|
|
* of the GNU General Public License, incorporated herein by reference.
|
|
|
|
*/
|
2005-04-16 15:20:36 -07:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/miscdevice.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include "os.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* core module and version information
|
|
|
|
*/
|
|
|
|
#define RNG_VERSION "1.0.0"
|
|
|
|
#define RNG_MODULE_NAME "random"
|
|
|
|
|
|
|
|
#define RNG_MISCDEV_MINOR 183 /* official */
|
|
|
|
|
2006-09-29 01:58:50 -07:00
|
|
|
/* Changed at init time, in the non-modular case, and at module load
|
|
|
|
* time, in the module case. Presumably, the module subsystem
|
|
|
|
* protects against a module being loaded twice at the same time.
|
|
|
|
*/
|
2005-04-16 15:20:36 -07:00
|
|
|
static int random_fd = -1;
|
|
|
|
|
|
|
|
static int rng_dev_open (struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
/* enforce read-only access to this chrdev */
|
|
|
|
if ((filp->f_mode & FMODE_READ) == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
if (filp->f_mode & FMODE_WRITE)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t rng_dev_read (struct file *filp, char __user *buf, size_t size,
|
|
|
|
loff_t * offp)
|
|
|
|
{
|
|
|
|
u32 data;
|
|
|
|
int n, ret = 0, have_data;
|
|
|
|
|
|
|
|
while(size){
|
uml: start fixing os_read_file and os_write_file
This patch starts the removal of a very old, very broken piece of code. This
stems from the problem of passing a userspace buffer into read() or write() on
the host. If that buffer had not yet been faulted in, read and write will
return -EFAULT.
To avoid this problem, the solution was to fault the buffer in before the
system call by touching the pages that hold the buffer by doing a copy-user of
a byte to each page. This is obviously bogus, but it does usually work, in tt
mode, since the kernel and process are in the same address space and userspace
addresses can be accessed directly in the kernel.
In skas mode, where the kernel and process are in separate address spaces, it
is completely bogus because the userspace address, which is invalid in the
kernel, is passed into the system call instead of the corresponding physical
address, which would be valid. Here, it appears that this code, on every host
read() or write(), tries to fault in a random process page. This doesn't seem
to cause any correctness problems, but there is a performance impact. This
patch, and the ones following, result in a 10-15% performance gain on a kernel
build.
This code can't be immediately tossed out because when it is, you can't log
in. Apparently, there is some code in the console driver which depends on
this somehow.
However, we can start removing it by switching the code which does I/O using
kernel addresses to using plain read() and write(). This patch introduces
os_read_file_k and os_write_file_k for use with kernel buffers and converts
all call locations which use obvious kernel buffers to use them. These
include I/O using buffers which are local variables which are on the stack or
kmalloc-ed. Later patches will handle the less obvious cases, followed by a
mass conversion back to the original interface.
Signed-off-by: Jeff Dike <jdike@linux.intel.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-06 14:51:32 -07:00
|
|
|
n = os_read_file_k(random_fd, &data, sizeof(data));
|
2005-04-16 15:20:36 -07:00
|
|
|
if(n > 0){
|
|
|
|
have_data = n;
|
|
|
|
while (have_data && size) {
|
|
|
|
if (put_user((u8)data, buf++)) {
|
|
|
|
ret = ret ? : -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
size--;
|
|
|
|
ret++;
|
|
|
|
have_data--;
|
|
|
|
data>>=8;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(n == -EAGAIN){
|
|
|
|
if (filp->f_flags & O_NONBLOCK)
|
|
|
|
return ret ? : -EAGAIN;
|
|
|
|
|
2005-11-07 02:01:14 -07:00
|
|
|
if(need_resched())
|
|
|
|
schedule_timeout_interruptible(1);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
else return n;
|
|
|
|
if (signal_pending (current))
|
|
|
|
return ret ? : -ERESTARTSYS;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-09-27 01:50:33 -07:00
|
|
|
static const struct file_operations rng_chrdev_ops = {
|
2005-04-16 15:20:36 -07:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = rng_dev_open,
|
|
|
|
.read = rng_dev_read,
|
|
|
|
};
|
|
|
|
|
2007-02-10 02:44:05 -07:00
|
|
|
/* rng_init shouldn't be called more than once at boot time */
|
2005-04-16 15:20:36 -07:00
|
|
|
static struct miscdevice rng_miscdev = {
|
|
|
|
RNG_MISCDEV_MINOR,
|
|
|
|
RNG_MODULE_NAME,
|
|
|
|
&rng_chrdev_ops,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* rng_init - initialize RNG module
|
|
|
|
*/
|
|
|
|
static int __init rng_init (void)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = os_open_file("/dev/random", of_read(OPENFLAGS()), 0);
|
|
|
|
if(err < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
random_fd = err;
|
|
|
|
|
|
|
|
err = os_set_fd_block(random_fd, 0);
|
|
|
|
if(err)
|
|
|
|
goto err_out_cleanup_hw;
|
|
|
|
|
|
|
|
err = misc_register (&rng_miscdev);
|
|
|
|
if (err) {
|
2005-05-28 15:51:58 -07:00
|
|
|
printk (KERN_ERR RNG_MODULE_NAME ": misc device register failed\n");
|
2005-04-16 15:20:36 -07:00
|
|
|
goto err_out_cleanup_hw;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err_out_cleanup_hw:
|
|
|
|
random_fd = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* rng_cleanup - shutdown RNG module
|
|
|
|
*/
|
|
|
|
static void __exit rng_cleanup (void)
|
|
|
|
{
|
|
|
|
misc_deregister (&rng_miscdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init (rng_init);
|
|
|
|
module_exit (rng_cleanup);
|
2005-05-28 15:51:58 -07:00
|
|
|
|
|
|
|
MODULE_DESCRIPTION("UML Host Random Number Generator (RNG) driver");
|
|
|
|
MODULE_LICENSE("GPL");
|