* /dev/kmem - kernel virtual memory
* /dev/null - null device (data sink)
* /dev/boot - boot device loaded from boot image
- * /dev/random - random number generator
* /dev/zero - null byte stream generator
*
* Changes:
#include "../../kernel/type.h"
#include "assert.h"
-#include "random.h"
#define NR_DEVS 7 /* number of minor devices */
-#define KRANDOM_PERIOD 1 /* ticks between krandom calls */
PRIVATE struct device m_geom[NR_DEVS]; /* base and size of each device */
PRIVATE int m_seg[NR_DEVS]; /* segment index of each device */
PRIVATE int m_device; /* current device */
PRIVATE struct kinfo kinfo; /* kernel information */
PRIVATE struct machine machine; /* machine information */
-PRIVATE struct randomness krandom; /* randomness from the kernel */
extern int errno; /* error number for PM calls */
FORWARD _PROTOTYPE( void m_init, (void) );
FORWARD _PROTOTYPE( int m_ioctl, (struct driver *dp, message *m_ptr) );
FORWARD _PROTOTYPE( void m_geometry, (struct partition *entry) );
-FORWARD _PROTOTYPE( void m_random, (struct driver *dp, message *m_ptr) );
/* Entry points to this driver. */
PRIVATE struct driver m_dtab = {
nop_cleanup, /* no need to clean up */
m_geometry, /* memory device "geometry" */
nop_signal, /* system signals */
- m_random, /* get randomness from kernel (alarm) */
+ nop_alarm,
nop_cancel,
nop_select,
NULL
#define ZERO_BUF_SIZE 1024
PRIVATE char dev_zero[ZERO_BUF_SIZE];
-/* Buffer for the /dev/random number generator. */
-#define RANDOM_BUF_SIZE 1024
-PRIVATE char random_buf[RANDOM_BUF_SIZE];
-
-
#define click_to_round_k(n) \
((unsigned) ((((unsigned long) (n) << CLICK_SHIFT) + 512) / 1024))
}
break;
- /* Random number generator. Character instead of block device. */
- case RANDOM_DEV:
- if (opcode == DEV_GATHER && !random_isseeded())
- return(EAGAIN);
- left = count;
- while (left > 0) {
- chunk = (left > RANDOM_BUF_SIZE) ? RANDOM_BUF_SIZE : left;
- if (opcode == DEV_GATHER) {
- random_getbytes(random_buf, chunk);
- sys_vircopy(SELF, D, (vir_bytes) random_buf,
- proc_nr, D, user_vir, chunk);
- } else if (opcode == DEV_SCATTER) {
- sys_vircopy(proc_nr, D, user_vir,
- SELF, D, (vir_bytes) random_buf, chunk);
- random_putbytes(random_buf, chunk);
- }
- user_vir += chunk;
- left -= chunk;
- }
- break;
-
/* Null byte stream generator. */
case ZERO_DEV:
if (opcode == DEV_GATHER) {
dev_zero[i] = '\0';
}
- random_init();
- m_random(NULL, NULL); /* also set periodic timer */
-
/* Set up memory ranges for /dev/mem. */
#if (CHIP == INTEL)
if (OK != (s=sys_getmachine(&machine))) {
}
-/*============================================================================*
- * m_random *
- *============================================================================*/
-PRIVATE void m_random(dp, m_ptr)
-struct driver *dp; /* pointer to driver structure */
-message *m_ptr; /* pointer to alarm message */
-{
- /* Fetch random information from the kernel to update /dev/random. */
- int i, s, r_next, r_size, r_high;
- struct randomness krandom;
-
- if (OK != (s=sys_getrandomness(&krandom)))
- report("MEM", "sys_getrandomness failed", s);
-
- for (i= 0; i<RANDOM_SOURCES; i++)
- {
- r_next= krandom.bin[i].r_next;
- r_size= krandom.bin[i].r_size;
- r_high= r_next+r_size;
- if (r_high <= RANDOM_ELEMENTS)
- {
- random_update(i, &krandom.bin[i].r_buf[r_next], r_size);
- }
- else
- {
- assert(r_next < RANDOM_ELEMENTS);
- random_update(i, &krandom.bin[i].r_buf[r_next],
- RANDOM_ELEMENTS-r_next);
- random_update(i, &krandom.bin[i].r_buf[0],
- r_high-RANDOM_ELEMENTS);
- }
- }
-
- /* Schedule new alarm for next m_random call. */
- if (OK != (s=sys_setalarm(KRANDOM_PERIOD, 0)))
- report("MEM", "sys_setalarm failed", s);
-}
-
/*============================================================================*
* m_geometry *
*============================================================================*/
--- /dev/null
+/* This file contains the device dependent part of the drivers for the
+ * following special files:
+ * /dev/random - random number generator
+ */
+
+#include "../drivers.h"
+#include "../libdriver/driver.h"
+#include <sys/ioc_memory.h>
+#include "../../kernel/const.h"
+#include "../../kernel/config.h"
+#include "../../kernel/type.h"
+
+#include "assert.h"
+#include "random.h"
+
+#define NR_DEVS 1 /* number of minor devices */
+# define RANDOM_DEV 0 /* minor device for /dev/random */
+
+#define KRANDOM_PERIOD 1 /* ticks between krandom calls */
+
+PRIVATE struct device m_geom[NR_DEVS]; /* base and size of each device */
+PRIVATE int m_device; /* current device */
+PRIVATE struct randomness krandom; /* randomness from the kernel */
+
+extern int errno; /* error number for PM calls */
+
+FORWARD _PROTOTYPE( char *r_name, (void) );
+FORWARD _PROTOTYPE( struct device *r_prepare, (int device) );
+FORWARD _PROTOTYPE( int r_transfer, (int proc_nr, int opcode, off_t position,
+ iovec_t *iov, unsigned nr_req) );
+FORWARD _PROTOTYPE( int r_do_open, (struct driver *dp, message *m_ptr) );
+FORWARD _PROTOTYPE( void r_init, (void) );
+FORWARD _PROTOTYPE( int r_ioctl, (struct driver *dp, message *m_ptr) );
+FORWARD _PROTOTYPE( void r_geometry, (struct partition *entry) );
+FORWARD _PROTOTYPE( void r_random, (struct driver *dp, message *m_ptr) );
+
+/* Entry points to this driver. */
+PRIVATE struct driver r_dtab = {
+ r_name, /* current device's name */
+ r_do_open, /* open or mount */
+ do_nop, /* nothing on a close */
+ r_ioctl, /* specify ram disk geometry */
+ r_prepare, /* prepare for I/O on a given minor device */
+ r_transfer, /* do the I/O */
+ nop_cleanup, /* no need to clean up */
+ r_geometry, /* device "geometry" */
+ nop_signal, /* system signals */
+ r_random, /* get randomness from kernel (alarm) */
+ nop_cancel,
+ nop_select,
+ NULL
+};
+
+/* Buffer for the /dev/random number generator. */
+#define RANDOM_BUF_SIZE 1024
+PRIVATE char random_buf[RANDOM_BUF_SIZE];
+
+
+/*===========================================================================*
+ * main *
+ *===========================================================================*/
+PUBLIC void main(void)
+{
+ r_init(); /* initialize the memory driver */
+ driver_task(&r_dtab); /* start driver's main loop */
+}
+
+
+/*===========================================================================*
+ * r_name *
+ *===========================================================================*/
+PRIVATE char *r_name()
+{
+/* Return a name for the current device. */
+ static char name[] = "random";
+ return name;
+}
+
+
+/*===========================================================================*
+ * r_prepare *
+ *===========================================================================*/
+PRIVATE struct device *r_prepare(device)
+int device;
+{
+/* Prepare for I/O on a device: check if the minor device number is ok. */
+
+ if (device < 0 || device >= NR_DEVS) return(NIL_DEV);
+ m_device = device;
+
+ return(&m_geom[device]);
+}
+
+
+/*===========================================================================*
+ * r_transfer *
+ *===========================================================================*/
+PRIVATE int r_transfer(proc_nr, opcode, position, iov, nr_req)
+int proc_nr; /* process doing the request */
+int opcode; /* DEV_GATHER or DEV_SCATTER */
+off_t position; /* offset on device to read or write */
+iovec_t *iov; /* pointer to read or write request vector */
+unsigned nr_req; /* length of request vector */
+{
+/* Read or write one the driver's minor devices. */
+ phys_bytes mem_phys, user_phys;
+ int seg;
+ unsigned count, left, chunk;
+ vir_bytes user_vir;
+ struct device *dv;
+ unsigned long dv_size;
+ int s;
+
+ /* Get minor device number and check for /dev/null. */
+ dv = &m_geom[m_device];
+ dv_size = cv64ul(dv->dv_size);
+
+ while (nr_req > 0) {
+
+ /* How much to transfer and where to / from. */
+ count = iov->iov_size;
+ user_vir = iov->iov_addr;
+
+ switch (m_device) {
+
+ /* Random number generator. Character instead of block device. */
+ case RANDOM_DEV:
+ if (opcode == DEV_GATHER && !random_isseeded())
+ return(EAGAIN);
+ left = count;
+ while (left > 0) {
+ chunk = (left > RANDOM_BUF_SIZE) ? RANDOM_BUF_SIZE : left;
+ if (opcode == DEV_GATHER) {
+ random_getbytes(random_buf, chunk);
+ sys_vircopy(SELF, D, (vir_bytes) random_buf,
+ proc_nr, D, user_vir, chunk);
+ } else if (opcode == DEV_SCATTER) {
+ sys_vircopy(proc_nr, D, user_vir,
+ SELF, D, (vir_bytes) random_buf, chunk);
+ random_putbytes(random_buf, chunk);
+ }
+ user_vir += chunk;
+ left -= chunk;
+ }
+ break;
+
+
+ /* Unknown (illegal) minor device. */
+ default:
+ return(EINVAL);
+ }
+
+ /* Book the number of bytes transferred. */
+ position += count;
+ iov->iov_addr += count;
+ if ((iov->iov_size -= count) == 0) { iov++; nr_req--; }
+
+ }
+ return(OK);
+}
+
+
+/*============================================================================*
+ * r_do_open *
+ *============================================================================*/
+PRIVATE int r_do_open(dp, m_ptr)
+struct driver *dp;
+message *m_ptr;
+{
+/* Check device number on open.
+ */
+ if (r_prepare(m_ptr->DEVICE) == NIL_DEV) return(ENXIO);
+
+ return(OK);
+}
+
+
+/*===========================================================================*
+ * r_init *
+ *===========================================================================*/
+PRIVATE void r_init()
+{
+ /* Initialize this task. All minor devices are initialized one by one. */
+ int i, s;
+
+ random_init();
+ r_random(NULL, NULL); /* also set periodic timer */
+}
+
+
+/*===========================================================================*
+ * r_ioctl *
+ *===========================================================================*/
+PRIVATE int r_ioctl(dp, m_ptr)
+struct driver *dp; /* pointer to driver structure */
+message *m_ptr; /* pointer to control message */
+{
+ struct device *dv;
+ if ((dv = r_prepare(m_ptr->DEVICE)) == NIL_DEV) return(ENXIO);
+
+ switch (m_ptr->REQUEST) {
+
+ default:
+ return(do_diocntl(&r_dtab, m_ptr));
+ }
+ return(OK);
+}
+
+
+/*============================================================================*
+ * r_random *
+ *============================================================================*/
+PRIVATE void r_random(dp, m_ptr)
+struct driver *dp; /* pointer to driver structure */
+message *m_ptr; /* pointer to alarm message */
+{
+ /* Fetch random information from the kernel to update /dev/random. */
+ int i, s, r_next, r_size, r_high;
+ struct randomness krandom;
+
+ if (OK != (s=sys_getrandomness(&krandom)))
+ report("RANDOM", "sys_getrandomness failed", s);
+
+ for (i= 0; i<RANDOM_SOURCES; i++)
+ {
+ r_next= krandom.bin[i].r_next;
+ r_size= krandom.bin[i].r_size;
+ r_high= r_next+r_size;
+ if (r_high <= RANDOM_ELEMENTS)
+ {
+ random_update(i, &krandom.bin[i].r_buf[r_next], r_size);
+ }
+ else
+ {
+ assert(r_next < RANDOM_ELEMENTS);
+ random_update(i, &krandom.bin[i].r_buf[r_next],
+ RANDOM_ELEMENTS-r_next);
+ random_update(i, &krandom.bin[i].r_buf[0],
+ r_high-RANDOM_ELEMENTS);
+ }
+ }
+
+ /* Schedule new alarm for next m_random call. */
+ if (OK != (s=sys_setalarm(KRANDOM_PERIOD, 0)))
+ report("RANDOM", "sys_setalarm failed", s);
+}
+
+/*============================================================================*
+ * r_geometry *
+ *============================================================================*/
+PRIVATE void r_geometry(entry)
+struct partition *entry;
+{
+ /* Memory devices don't have a geometry, but the outside world insists. */
+ entry->cylinders = div64u(m_geom[m_device].dv_size, SECTOR_SIZE) / (64 * 32);
+ entry->heads = 64;
+ entry->sectors = 32;
+}
+
+