f08f2bd88c
have malloc/free, alloc_contig/free_contig and mmap/munmap nicely paired up. memory uses malloc/free instead of mmap/munmap as it doesn't have to be contiguous for the ramdisks (and it might help if it doesn't!).
494 lines
14 KiB
C
494 lines
14 KiB
C
/* This file contains the device dependent part of the drivers for the
|
|
* following special files:
|
|
* /dev/ram - RAM disk
|
|
* /dev/mem - absolute memory
|
|
* /dev/kmem - kernel virtual memory
|
|
* /dev/null - null device (data sink)
|
|
* /dev/boot - boot device loaded from boot image
|
|
* /dev/zero - null byte stream generator
|
|
* /dev/imgrd - boot image RAM disk
|
|
*
|
|
* Changes:
|
|
* Apr 29, 2005 added null byte generator (Jorrit N. Herder)
|
|
* Apr 09, 2005 added support for boot device (Jorrit N. Herder)
|
|
* Jul 26, 2004 moved RAM driver to user-space (Jorrit N. Herder)
|
|
* Apr 20, 1992 device dependent/independent split (Kees J. Bot)
|
|
*/
|
|
|
|
#include "../drivers.h"
|
|
#include "../libdriver/driver.h"
|
|
#include <sys/ioc_memory.h>
|
|
#include <minix/ds.h>
|
|
#include <minix/vm.h>
|
|
#include <sys/mman.h>
|
|
#include "../../kernel/const.h"
|
|
#include "../../kernel/config.h"
|
|
#include "../../kernel/type.h"
|
|
|
|
#include <sys/vm_i386.h>
|
|
|
|
#include "local.h"
|
|
|
|
/* ramdisks (/dev/ram*) */
|
|
#define RAMDISKS 6
|
|
|
|
#define RAM_DEV_LAST (RAM_DEV_FIRST+RAMDISKS-1)
|
|
|
|
#define NR_DEVS (7+RAMDISKS) /* number of minor devices */
|
|
|
|
PRIVATE struct device m_geom[NR_DEVS]; /* base and size of each device */
|
|
PRIVATE vir_bytes m_vaddrs[NR_DEVS];
|
|
PRIVATE int m_device; /* current device */
|
|
PRIVATE struct kinfo kinfo; /* kernel information */
|
|
|
|
extern int errno; /* error number for PM calls */
|
|
|
|
PRIVATE int openct[NR_DEVS];
|
|
|
|
FORWARD _PROTOTYPE( char *m_name, (void) );
|
|
FORWARD _PROTOTYPE( struct device *m_prepare, (int device) );
|
|
FORWARD _PROTOTYPE( int m_transfer, (int proc_nr, int opcode,
|
|
u64_t position, iovec_t *iov, unsigned nr_req) );
|
|
FORWARD _PROTOTYPE( int m_do_open, (struct driver *dp, message *m_ptr) );
|
|
FORWARD _PROTOTYPE( int m_do_close, (struct driver *dp, message *m_ptr) );
|
|
FORWARD _PROTOTYPE( int m_ioctl, (struct driver *dp, message *m_ptr) );
|
|
FORWARD _PROTOTYPE( void m_geometry, (struct partition *entry) );
|
|
|
|
/* Entry points to this driver. */
|
|
PRIVATE struct driver m_dtab = {
|
|
m_name, /* current device's name */
|
|
m_do_open, /* open or mount */
|
|
m_do_close, /* nothing on a close */
|
|
m_ioctl, /* specify ram disk geometry */
|
|
m_prepare, /* prepare for I/O on a given minor device */
|
|
m_transfer, /* do the I/O */
|
|
nop_cleanup, /* no need to clean up */
|
|
m_geometry, /* memory device "geometry" */
|
|
nop_signal, /* system signals */
|
|
nop_alarm,
|
|
nop_cancel,
|
|
nop_select,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
/* Buffer for the /dev/zero null byte feed. */
|
|
#define ZERO_BUF_SIZE 1024
|
|
PRIVATE char dev_zero[ZERO_BUF_SIZE];
|
|
|
|
#define click_to_round_k(n) \
|
|
((unsigned) ((((unsigned long) (n) << CLICK_SHIFT) + 512) / 1024))
|
|
|
|
/* SEF functions and variables. */
|
|
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
|
|
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
|
|
|
|
/*===========================================================================*
|
|
* main *
|
|
*===========================================================================*/
|
|
PUBLIC int main(void)
|
|
{
|
|
/* SEF local startup. */
|
|
sef_local_startup();
|
|
|
|
/* Call the generic receive loop. */
|
|
driver_task(&m_dtab, DRIVER_STD);
|
|
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* sef_local_startup *
|
|
*===========================================================================*/
|
|
PRIVATE void sef_local_startup()
|
|
{
|
|
/* Register init callbacks. */
|
|
sef_setcb_init_fresh(sef_cb_init_fresh);
|
|
sef_setcb_init_lu(sef_cb_init_fresh);
|
|
sef_setcb_init_restart(sef_cb_init_fresh);
|
|
|
|
/* Register live update callbacks. */
|
|
sef_setcb_lu_prepare(sef_cb_lu_prepare_always_ready);
|
|
sef_setcb_lu_state_isvalid(sef_cb_lu_state_isvalid_standard);
|
|
|
|
/* Let SEF perform startup. */
|
|
sef_startup();
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* sef_cb_init_fresh *
|
|
*===========================================================================*/
|
|
PRIVATE int sef_cb_init_fresh(int type, sef_init_info_t *info)
|
|
{
|
|
/* Initialize the memory driver. */
|
|
struct sigaction sa;
|
|
u32_t ramdev_size;
|
|
int i, s;
|
|
|
|
sa.sa_handler = SIG_MESS;
|
|
sigemptyset(&sa.sa_mask);
|
|
sa.sa_flags = 0;
|
|
if (sigaction(SIGTERM,&sa,NULL)<0) panic("MEM","sigaction failed", errno);
|
|
|
|
/* Initialize all minor devices one by one. */
|
|
if (OK != (s=sys_getkinfo(&kinfo))) {
|
|
panic("MEM","Couldn't get kernel information.",s);
|
|
}
|
|
|
|
#if 0
|
|
/* Map in kernel memory for /dev/kmem. */
|
|
m_geom[KMEM_DEV].dv_base = cvul64(kinfo.kmem_base);
|
|
m_geom[KMEM_DEV].dv_size = cvul64(kinfo.kmem_size);
|
|
if((m_vaddrs[KMEM_DEV] = vm_map_phys(SELF, (void *) kinfo.kmem_base,
|
|
kinfo.kmem_size)) == MAP_FAILED) {
|
|
printf("MEM: Couldn't map in /dev/kmem.");
|
|
}
|
|
#endif
|
|
|
|
/* Ramdisk image built into the memory driver */
|
|
m_geom[IMGRD_DEV].dv_base= cvul64(0);
|
|
m_geom[IMGRD_DEV].dv_size= cvul64(imgrd_size);
|
|
m_vaddrs[IMGRD_DEV] = (vir_bytes) imgrd;
|
|
|
|
/* Initialize /dev/zero. Simply write zeros into the buffer. */
|
|
for (i=0; i<ZERO_BUF_SIZE; i++) {
|
|
dev_zero[i] = '\0';
|
|
}
|
|
|
|
for(i = 0; i < NR_DEVS; i++)
|
|
openct[i] = 0;
|
|
|
|
/* Set up memory range for /dev/mem. */
|
|
m_geom[MEM_DEV].dv_base = cvul64(0);
|
|
m_geom[MEM_DEV].dv_size = cvul64(0xffffffff);
|
|
|
|
m_vaddrs[MEM_DEV] = (vir_bytes) MAP_FAILED; /* we are not mapping this in. */
|
|
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* m_name *
|
|
*===========================================================================*/
|
|
PRIVATE char *m_name()
|
|
{
|
|
/* Return a name for the current device. */
|
|
static char name[] = "memory";
|
|
return name;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* m_prepare *
|
|
*===========================================================================*/
|
|
PRIVATE struct device *m_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]);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* m_transfer *
|
|
*===========================================================================*/
|
|
PRIVATE int m_transfer(proc_nr, opcode, pos64, iov, nr_req)
|
|
int proc_nr; /* process doing the request */
|
|
int opcode; /* DEV_GATHER_S or DEV_SCATTER_S */
|
|
u64_t pos64; /* 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. */
|
|
unsigned count, left, chunk;
|
|
vir_bytes user_vir, vir_offset = 0;
|
|
struct device *dv;
|
|
unsigned long dv_size;
|
|
int s, r;
|
|
off_t position;
|
|
vir_bytes dev_vaddr;
|
|
|
|
/* ZERO_DEV and NULL_DEV are infinite in size. */
|
|
if (m_device != ZERO_DEV && m_device != NULL_DEV && ex64hi(pos64) != 0)
|
|
return OK; /* Beyond EOF */
|
|
position= cv64ul(pos64);
|
|
|
|
/* Get minor device number and check for /dev/null. */
|
|
dv = &m_geom[m_device];
|
|
dv_size = cv64ul(dv->dv_size);
|
|
dev_vaddr = m_vaddrs[m_device];
|
|
|
|
while (nr_req > 0) {
|
|
|
|
/* How much to transfer and where to / from. */
|
|
count = iov->iov_size;
|
|
user_vir = iov->iov_addr;
|
|
|
|
switch (m_device) {
|
|
|
|
/* No copying; ignore request. */
|
|
case NULL_DEV:
|
|
if (opcode == DEV_GATHER_S) return(OK); /* always at EOF */
|
|
break;
|
|
|
|
/* Virtual copying. For RAM disks, kernel memory and internal FS. */
|
|
default:
|
|
case KMEM_DEV:
|
|
case RAM_DEV_OLD:
|
|
case IMGRD_DEV:
|
|
/* Bogus number. */
|
|
if(m_device < 0 || m_device >= NR_DEVS) {
|
|
return(EINVAL);
|
|
}
|
|
if(!dev_vaddr || dev_vaddr == (vir_bytes) MAP_FAILED) {
|
|
printf("MEM: dev %d not initialized\n", m_device);
|
|
return EIO;
|
|
}
|
|
if (position >= dv_size) return(OK); /* check for EOF */
|
|
if (position + count > dv_size) count = dv_size - position;
|
|
if (opcode == DEV_GATHER_S) { /* copy actual data */
|
|
r=sys_safecopyto(proc_nr, user_vir, vir_offset,
|
|
dev_vaddr + position, count, D);
|
|
} else {
|
|
r=sys_safecopyfrom(proc_nr, user_vir, vir_offset,
|
|
dev_vaddr + position, count, D);
|
|
}
|
|
if(r != OK) {
|
|
panic("MEM","I/O copy failed",r);
|
|
}
|
|
break;
|
|
|
|
/* Physical copying. Only used to access entire memory.
|
|
* Transfer one 'page window' at a time.
|
|
*/
|
|
case MEM_DEV:
|
|
{
|
|
u32_t pagestart, page_off;
|
|
static u32_t pagestart_mapped;
|
|
static int any_mapped = 0;
|
|
static char *vaddr;
|
|
int r;
|
|
u32_t subcount;
|
|
phys_bytes mem_phys;
|
|
|
|
if (position >= dv_size)
|
|
return(OK); /* check for EOF */
|
|
if (position + count > dv_size)
|
|
count = dv_size - position;
|
|
mem_phys = position;
|
|
|
|
page_off = mem_phys % I386_PAGE_SIZE;
|
|
pagestart = mem_phys - page_off;
|
|
|
|
/* All memory to the map call has to be page-aligned.
|
|
* Don't have to map same page over and over.
|
|
*/
|
|
if(!any_mapped || pagestart_mapped != pagestart) {
|
|
if(any_mapped) {
|
|
if(vm_unmap_phys(SELF, vaddr, I386_PAGE_SIZE) != OK)
|
|
panic("MEM","vm_unmap_phys failed",NO_NUM);
|
|
any_mapped = 0;
|
|
}
|
|
vaddr = vm_map_phys(SELF, (void *) pagestart, I386_PAGE_SIZE);
|
|
if(vaddr == MAP_FAILED)
|
|
r = ENOMEM;
|
|
else
|
|
r = OK;
|
|
if(r != OK) {
|
|
printf("memory: vm_map_phys failed\n");
|
|
return r;
|
|
}
|
|
any_mapped = 1;
|
|
pagestart_mapped = pagestart;
|
|
}
|
|
|
|
/* how much to be done within this page. */
|
|
subcount = I386_PAGE_SIZE-page_off;
|
|
if(subcount > count)
|
|
subcount = count;
|
|
|
|
if (opcode == DEV_GATHER_S) { /* copy data */
|
|
s=sys_safecopyto(proc_nr, user_vir,
|
|
vir_offset, (vir_bytes) vaddr+page_off, subcount, D);
|
|
} else {
|
|
s=sys_safecopyfrom(proc_nr, user_vir,
|
|
vir_offset, (vir_bytes) vaddr+page_off, subcount, D);
|
|
}
|
|
if(s != OK)
|
|
return s;
|
|
count = subcount;
|
|
break;
|
|
}
|
|
|
|
/* Null byte stream generator. */
|
|
case ZERO_DEV:
|
|
if (opcode == DEV_GATHER_S) {
|
|
size_t suboffset = 0;
|
|
left = count;
|
|
while (left > 0) {
|
|
chunk = (left > ZERO_BUF_SIZE) ? ZERO_BUF_SIZE : left;
|
|
s=sys_safecopyto(proc_nr, user_vir,
|
|
vir_offset+suboffset, (vir_bytes) dev_zero, chunk, D);
|
|
if(s != OK)
|
|
report("MEM","sys_safecopyto failed", s);
|
|
left -= chunk;
|
|
suboffset += chunk;
|
|
}
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
/* Book the number of bytes transferred. */
|
|
position += count;
|
|
vir_offset += count;
|
|
if ((iov->iov_size -= count) == 0) { iov++; nr_req--; vir_offset = 0; }
|
|
|
|
}
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* m_do_open *
|
|
*===========================================================================*/
|
|
PRIVATE int m_do_open(dp, m_ptr)
|
|
struct driver *dp;
|
|
message *m_ptr;
|
|
{
|
|
int r;
|
|
|
|
/* Check device number on open. */
|
|
if (m_prepare(m_ptr->DEVICE) == NIL_DEV) return(ENXIO);
|
|
if (m_device == MEM_DEV)
|
|
{
|
|
r = sys_enable_iop(m_ptr->IO_ENDPT);
|
|
if (r != OK)
|
|
{
|
|
printf("m_do_open: sys_enable_iop failed for %d: %d\n",
|
|
m_ptr->IO_ENDPT, r);
|
|
return r;
|
|
}
|
|
}
|
|
|
|
if(m_device < 0 || m_device >= NR_DEVS) {
|
|
panic("MEM","wrong m_device",m_device);
|
|
}
|
|
|
|
openct[m_device]++;
|
|
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* m_do_close *
|
|
*===========================================================================*/
|
|
PRIVATE int m_do_close(dp, m_ptr)
|
|
struct driver *dp;
|
|
message *m_ptr;
|
|
{
|
|
int r;
|
|
|
|
if (m_prepare(m_ptr->DEVICE) == NIL_DEV) return(ENXIO);
|
|
|
|
if(m_device < 0 || m_device >= NR_DEVS) {
|
|
panic("MEM","wrong m_device",m_device);
|
|
}
|
|
|
|
if(openct[m_device] < 1) {
|
|
panic("MEM","closed too often",NO_NUM);
|
|
}
|
|
openct[m_device]--;
|
|
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* m_ioctl *
|
|
*===========================================================================*/
|
|
PRIVATE int m_ioctl(dp, m_ptr)
|
|
struct driver *dp; /* pointer to driver structure */
|
|
message *m_ptr; /* pointer to control message */
|
|
{
|
|
/* I/O controls for the memory driver. Currently there is one I/O control:
|
|
* - MIOCRAMSIZE: to set the size of the RAM disk.
|
|
*/
|
|
struct device *dv;
|
|
|
|
switch (m_ptr->REQUEST) {
|
|
case MIOCRAMSIZE: {
|
|
/* Someone wants to create a new RAM disk with the given size. */
|
|
u32_t ramdev_size;
|
|
int s, dev;
|
|
void *mem;
|
|
|
|
/* A ramdisk can be created only once, and only on RAM disk device. */
|
|
dev = m_ptr->DEVICE;
|
|
if(dev < 0 || dev >= NR_DEVS) {
|
|
printf("MEM: MIOCRAMSIZE: %d not a valid device\n", dev);
|
|
}
|
|
if((dev < RAM_DEV_FIRST || dev > RAM_DEV_LAST) && dev != RAM_DEV_OLD) {
|
|
printf("MEM: MIOCRAMSIZE: %d not a ramdisk\n", dev);
|
|
}
|
|
if ((dv = m_prepare(dev)) == NIL_DEV) return(ENXIO);
|
|
|
|
/* Get request structure */
|
|
s= sys_safecopyfrom(m_ptr->IO_ENDPT, (vir_bytes)m_ptr->IO_GRANT,
|
|
0, (vir_bytes)&ramdev_size, sizeof(ramdev_size), D);
|
|
if (s != OK)
|
|
return s;
|
|
if(m_vaddrs[dev] && !cmp64(dv->dv_size, cvul64(ramdev_size))) {
|
|
return(OK);
|
|
}
|
|
/* openct is 1 for the ioctl(). */
|
|
if(openct[dev] != 1) {
|
|
printf("MEM: MIOCRAMSIZE: %d in use (count %d)\n",
|
|
dev, openct[dev]);
|
|
return(EBUSY);
|
|
}
|
|
if(m_vaddrs[dev]) {
|
|
u32_t size;
|
|
if(ex64hi(dv->dv_size)) {
|
|
panic("MEM","huge old ramdisk", NO_NUM);
|
|
}
|
|
size = ex64lo(dv->dv_size);
|
|
free((void *) m_vaddrs[dev]);
|
|
m_vaddrs[dev] = (vir_bytes) NULL;
|
|
}
|
|
|
|
#if DEBUG
|
|
printf("MEM:%d: allocating ramdisk of size 0x%x\n", dev, ramdev_size);
|
|
#endif
|
|
|
|
/* Try to allocate a piece of memory for the RAM disk. */
|
|
if(!(mem = malloc(ramdev_size))) {
|
|
printf("MEM: failed to get memory for ramdisk\n");
|
|
return(ENOMEM);
|
|
}
|
|
memset(mem, 0, ramdev_size);
|
|
|
|
m_vaddrs[dev] = (vir_bytes) mem;
|
|
|
|
dv->dv_size = cvul64(ramdev_size);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return(do_diocntl(&m_dtab, m_ptr));
|
|
}
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* m_geometry *
|
|
*===========================================================================*/
|
|
PRIVATE void m_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;
|
|
}
|
|
|