Strip out the machine-independant parts of the memory device.

/dev/(u)random, /dev/null, /dev/zero are all moving to machine-independant
drivers.
Reviewed by:	dfr

2 files changed, 50 insertions, 257 deletions

diff --git a/sys/amd64/amd64/machdep.c b/sys/amd64/amd64/machdep.c
index 0b8aca9..ef6ac62 100644
--- a/sys/amd64/amd64/machdep.c
+++ b/sys/amd64/amd64/machdep.c
@@ -112,7 +112,6 @@
 #include <i386/isa/intr_machdep.h>
 #include <isa/rtc.h>
 #include <machine/vm86.h>
-#include <sys/random.h>
 #include <sys/ptrace.h>
 #include <machine/sigframe.h>
 
@@ -1908,7 +1907,6 @@ init386(first)
 #if	NISA >0
 	isa_defaultirq();
 #endif
-	rand_initialize();
 
 #ifdef DDB
 	kdb_init();
diff --git a/sys/amd64/amd64/mem.c b/sys/amd64/amd64/mem.c
index 9a4c715..52e964c 100644
--- a/sys/amd64/amd64/mem.c
+++ b/sys/amd64/amd64/mem.c
@@ -53,27 +53,26 @@
 #include <sys/malloc.h>
 #include <sys/memrange.h>
 #include <sys/proc.h>
-#include <sys/random.h>
 #include <sys/signalvar.h>
 #include <sys/systm.h>
 #include <sys/uio.h>
 
+#include <machine/db_machdep.h>
 #include <machine/frame.h>
 #include <machine/psl.h>
 #include <machine/specialreg.h>
-#include <i386/isa/intr_machdep.h>
 
 #include <vm/vm.h>
 #include <vm/pmap.h>
 #include <vm/vm_extern.h>
 
+static dev_t memdev, kmemdev, iodev;
 
 static	d_open_t	mmopen;
 static	d_close_t	mmclose;
 static	d_read_t	mmrw;
 static	d_ioctl_t	mmioctl;
 static	d_mmap_t	memmmap;
-static	d_poll_t	mmpoll;
 
 #define CDEV_MAJOR 2
 static struct cdevsw mem_cdevsw = {
@@ -82,7 +81,7 @@ static struct cdevsw mem_cdevsw = {
 	/* read */	mmrw,
 	/* write */	mmrw,
 	/* ioctl */	mmioctl,
-	/* poll */	mmpoll,
+	/* poll */	(d_poll_t *)seltrue,
 	/* mmap */	memmmap,
 	/* strategy */	nostrategy,
 	/* name */	"mem",
@@ -93,39 +92,22 @@ static struct cdevsw mem_cdevsw = {
 	/* bmaj */	-1
 };
 
-static struct random_softc random_softc[16];
-static caddr_t	zbuf;
-
 MALLOC_DEFINE(M_MEMDESC, "memdesc", "memory range descriptors");
-static int mem_ioctl __P((dev_t, u_long, caddr_t, int, struct proc *));
-static int random_ioctl __P((dev_t, u_long, caddr_t, int, struct proc *));
 
 struct mem_range_softc mem_range_softc;
 
-
 static int
-mmclose(dev, flags, fmt, p)
-	dev_t dev;
-	int flags;
-	int fmt;
-	struct proc *p;
+mmclose(dev_t dev, int flags, int fmt, struct proc *p)
 {
 	switch (minor(dev)) {
 	case 14:
 		p->p_md.md_regs->tf_eflags &= ~PSL_IOPL;
-		break;
-	default:
-		break;
 	}
 	return (0);
 }
 
 static int
-mmopen(dev, flags, fmt, p)
-	dev_t dev;
-	int flags;
-	int fmt;
-	struct proc *p;
+mmopen(dev_t dev, int flags, int fmt, struct proc *p)
 {
 	int error;
 
@@ -143,24 +125,19 @@ mmopen(dev, flags, fmt, p)
 			return (EPERM);
 		p->p_md.md_regs->tf_eflags |= PSL_IOPL;
 		break;
-	default:
-		break;
 	}
 	return (0);
 }
 
+/*ARGSUSED*/
 static int
-mmrw(dev, uio, flags)
-	dev_t dev;
-	struct uio *uio;
-	int flags;
+mmrw(dev_t dev, struct uio *uio, int flags)
 {
-	register int o;
-	register u_int c, v;
-	u_int poolsize;
-	register struct iovec *iov;
+	int o;
+	u_int c, v;
+	struct iovec *iov;
 	int error = 0;
-	caddr_t buf = NULL;
+	vm_offset_t addr, eaddr;
 
 	while (uio->uio_resid > 0 && error == 0) {
 		iov = uio->uio_iov;
@@ -187,8 +164,7 @@ mmrw(dev, uio, flags)
 			continue;
 
 /* minor device 1 is kernel memory */
-		case 1: {
-			vm_offset_t addr, eaddr;
+		case 1:
 			c = iov->iov_len;
 
 			/*
@@ -214,76 +190,6 @@ mmrw(dev, uio, flags)
 			continue;
 		}
 
-/* minor device 2 is EOF/RATHOLE */
-		case 2:
-			if (uio->uio_rw == UIO_READ)
-				return (0);
-			c = iov->iov_len;
-			break;
-
-/* minor device 3 (/dev/random) is source of filth on read, rathole on write */
-		case 3:
-			if (uio->uio_rw == UIO_WRITE) {
-				c = iov->iov_len;
-				break;
-			}
-			if (buf == NULL)
-				buf = (caddr_t)
-				    malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
-			c = min(iov->iov_len, PAGE_SIZE);
-			poolsize = read_random(buf, c);
-			if (poolsize == 0) {
-				if (buf)
-					free(buf, M_TEMP);
-				return (0);
-			}
-			c = min(c, poolsize);
-			error = uiomove(buf, (int)c, uio);
-			continue;
-
-/* minor device 4 (/dev/urandom) is source of muck on read, rathole on write */
-		case 4:
-			if (uio->uio_rw == UIO_WRITE) {
-				c = iov->iov_len;
-				break;
-			}
-			if (CURSIG(curproc) != 0) {
-				/*
-				 * Use tsleep() to get the error code right.
-				 * It should return immediately.
-				 */
-				error = tsleep(&random_softc[0],
-				    PZERO | PCATCH, "urand", 1);
-				if (error != 0 && error != EWOULDBLOCK)
-					continue;
-			}
-			if (buf == NULL)
-				buf = (caddr_t)
-				    malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
-			c = min(iov->iov_len, PAGE_SIZE);
-			poolsize = read_random_unlimited(buf, c);
-			c = min(c, poolsize);
-			error = uiomove(buf, (int)c, uio);
-			continue;
-
-/* minor device 12 (/dev/zero) is source of nulls on read, rathole on write */
-		case 12:
-			if (uio->uio_rw == UIO_WRITE) {
-				c = iov->iov_len;
-				break;
-			}
-			if (zbuf == NULL) {
-				zbuf = (caddr_t)
-				    malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
-				bzero(zbuf, PAGE_SIZE);
-			}
-			c = min(iov->iov_len, PAGE_SIZE);
-			error = uiomove(zbuf, (int)c, uio);
-			continue;
-
-		default:
-			return (ENXIO);
-		}
 		if (error)
 			break;
 		iov->iov_base += c;
@@ -291,56 +197,29 @@ mmrw(dev, uio, flags)
 		uio->uio_offset += c;
 		uio->uio_resid -= c;
 	}
-	if (buf)
-		free(buf, M_TEMP);
 	return (error);
 }
 
-
-
-
 /*******************************************************\
 * allow user processes to MMAP some memory sections	*
 * instead of going through read/write			*
 \*******************************************************/
 static int
-memmmap(dev_t dev, vm_offset_t offset, int nprot)
+memmmap(dev_t dev, vm_offset_t offset, int prot)
 {
 	switch (minor(dev))
 	{
 
-/* minor device 0 is physical memory */
+	/* minor device 0 is physical memory */
 	case 0:
         	return i386_btop(offset);
 
-/* minor device 1 is kernel memory */
+	/* minor device 1 is kernel memory */
 	case 1:
         	return i386_btop(vtophys(offset));
-
-	default:
-		return -1;
 	}
 }
 
-static int
-mmioctl(dev, cmd, data, flags, p)
-	dev_t dev;
-	u_long cmd;
-	caddr_t data;
-	int flags;
-	struct proc *p;
-{
-
-	switch (minor(dev)) {
-	case 0:
-		return mem_ioctl(dev, cmd, data, flags, p);
-	case 3:
-	case 4:
-		return random_ioctl(dev, cmd, data, flags, p);
-	}
-	return (ENODEV);
-}
-
 /*
  * Operations for changing memory attributes.
  *
@@ -348,12 +227,7 @@ mmioctl(dev, cmd, data, flags, p)
  * and mem_range_attr_set.
  */
 static int 
-mem_ioctl(dev, cmd, data, flags, p)
-	dev_t dev;
-	u_long cmd;
-	caddr_t data;
-	int flags;
-	struct proc *p;
+mmioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p)
 {
 	int nd, error = 0;
 	struct mem_range_op *mo = (struct mem_range_op *)data;
@@ -409,9 +283,7 @@ mem_ioctl(dev, cmd, data, flags, p)
  * memory range attributes.
  */
 int
-mem_range_attr_get(mrd, arg)
-	struct mem_range_desc *mrd;
-	int *arg;
+mem_range_attr_get(struct mem_range_desc *mrd, int *arg)
 {
 	/* can we handle this? */
 	if (mem_range_softc.mr_op == NULL)
@@ -419,16 +291,16 @@ mem_range_attr_get(mrd, arg)
 
 	if (*arg == 0) {
 		*arg = mem_range_softc.mr_ndesc;
-	} else {
-		bcopy(mem_range_softc.mr_desc, mrd, (*arg) * sizeof(struct mem_range_desc));
+	}
+	else {
+		bcopy(mem_range_softc.mr_desc, mrd,
+			(*arg) * sizeof(struct mem_range_desc));
 	}
 	return (0);
 }
 
 int
-mem_range_attr_set(mrd, arg)
-	struct mem_range_desc *mrd;
-	int *arg;
+mem_range_attr_set(struct mem_range_desc *mrd, int *arg)
 {
 	/* can we handle this? */
 	if (mem_range_softc.mr_op == NULL)
@@ -446,114 +318,37 @@ mem_range_AP_init(void)
 }
 #endif
 
-static int 
-random_ioctl(dev, cmd, data, flags, p)
-	dev_t dev;
-	u_long cmd;
-	caddr_t data;
-	int flags;
-	struct proc *p;
+static int
+mem_modevent(module_t mod, int type, void *data)
 {
-	static intrmask_t interrupt_allowed;
-	intrmask_t interrupt_mask;
-	int error, intr;
-	struct random_softc *sc;
-	
-	/*
-	 * We're the random or urandom device.  The only ioctls are for
-	 * selecting and inspecting which interrupts are used in the muck
-	 * gathering business.
-	 */
-	if (cmd != MEM_SETIRQ && cmd != MEM_CLEARIRQ && cmd != MEM_RETURNIRQ)
-		return (ENOTTY);
+	switch(type) {
+	case MOD_LOAD:
+		if (bootverbose)
+			printf("mem: <memory & I/O>\n");
+		/* Initialise memory range handling */
+		if (mem_range_softc.mr_op != NULL)
+			mem_range_softc.mr_op->init(&mem_range_softc);
+
+		memdev = make_dev(&mem_cdevsw, 0, UID_ROOT, GID_KMEM,
+			0640, "mem");
+		kmemdev = make_dev(&mem_cdevsw, 1, UID_ROOT, GID_KMEM,
+			0640, "kmem");
+		iodev = make_dev(&mem_cdevsw, 14, UID_ROOT, GID_WHEEL,
+			0600, "io");
+		return 0;
+
+	case MOD_UNLOAD:
+		destroy_dev(memdev);
+		destroy_dev(kmemdev);
+		destroy_dev(iodev);
+		return 0;
+
+	case MOD_SHUTDOWN:
+		return 0;
 
-	/*
-	 * Even inspecting the state is privileged, since it gives a hint
-	 * about how easily the randomness might be guessed.
-	 */
-	error = suser(p);
-	if (error != 0)
-		return (error);
-
-	/*
-	 * XXX the data is 16-bit due to a historical botch, so we use
-	 * magic 16's instead of ICU_LEN and can't support 24 interrupts
-	 * under SMP.
-	 */
-	intr = *(int16_t *)data;
-	if (cmd != MEM_RETURNIRQ && (intr < 0 || intr >= 16))
-		return (EINVAL);
-
-	interrupt_mask = 1 << intr;
-	sc = &random_softc[intr];
-	switch (cmd) {
-	case MEM_SETIRQ:
-		if (interrupt_allowed & interrupt_mask)
-			break;
-		interrupt_allowed |= interrupt_mask;
-		sc->sc_intr = intr;
-		disable_intr();
-		sc->sc_handler = intr_handler[intr];
-		intr_handler[intr] = add_interrupt_randomness;
-		sc->sc_arg = intr_unit[intr];
-		intr_unit[intr] = sc;
-		enable_intr();
-		break;
-	case MEM_CLEARIRQ:
-		if (!(interrupt_allowed & interrupt_mask))
-			break;
-		interrupt_allowed &= ~interrupt_mask;
-		disable_intr();
-		intr_handler[intr] = sc->sc_handler;
-		intr_unit[intr] = sc->sc_arg;
-		enable_intr();
-		break;
-	case MEM_RETURNIRQ:
-		*(u_int16_t *)data = interrupt_allowed;
-		break;
-	}
-	return (0);
-}
-
-int
-mmpoll(dev, events, p)
-	dev_t dev;
-	int events;
-	struct proc *p;
-{
-	switch (minor(dev)) {
-	case 3:		/* /dev/random */
-		return random_poll(dev, events, p);
-	case 4:		/* /dev/urandom */
 	default:
-		return seltrue(dev, events, p);
+		return EOPNOTSUPP;
 	}
 }
 
-int
-iszerodev(dev)
-	dev_t dev;
-{
-	return ((major(dev) == mem_cdevsw.d_maj)
-	  && minor(dev) == 12);
-}
-
-static void
-mem_drvinit(void *unused)
-{
-
-	/* Initialise memory range handling */
-	if (mem_range_softc.mr_op != NULL)
-		mem_range_softc.mr_op->init(&mem_range_softc);
-
-	make_dev(&mem_cdevsw, 0, UID_ROOT, GID_KMEM, 0640, "mem");
-	make_dev(&mem_cdevsw, 1, UID_ROOT, GID_KMEM, 0640, "kmem");
-	make_dev(&mem_cdevsw, 2, UID_ROOT, GID_WHEEL, 0666, "null");
-	make_dev(&mem_cdevsw, 3, UID_ROOT, GID_WHEEL, 0644, "random");
-	make_dev(&mem_cdevsw, 4, UID_ROOT, GID_WHEEL, 0644, "urandom");
-	make_dev(&mem_cdevsw, 12, UID_ROOT, GID_WHEEL, 0666, "zero");
-	make_dev(&mem_cdevsw, 14, UID_ROOT, GID_WHEEL, 0600, "io");
-}
-
-SYSINIT(memdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,mem_drvinit,NULL)
-
+DEV_MODULE(mem, mem_modevent, NULL);