2005-04-21 16:53:53 +02:00
|
|
|
/* 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)
|
2005-04-29 17:36:43 +02:00
|
|
|
* /dev/boot - boot device loaded from boot image
|
|
|
|
* /dev/zero - null byte stream generator
|
2005-04-21 16:53:53 +02:00
|
|
|
*
|
|
|
|
* Changes:
|
2005-04-29 17:36:43 +02:00
|
|
|
* Apr 29, 2005 added null byte generator (Jorrit N. Herder)
|
|
|
|
* Apr 09, 2005 added support for boot device (Jorrit N. Herder)
|
2005-04-21 16:53:53 +02:00
|
|
|
* 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"
|
2005-06-03 15:55:06 +02:00
|
|
|
#include <sys/ioc_memory.h>
|
2007-02-16 16:57:05 +01:00
|
|
|
#include <env.h>
|
2006-07-13 16:50:23 +02:00
|
|
|
#include <minix/ds.h>
|
2008-12-11 15:42:23 +01:00
|
|
|
#include <minix/vm.h>
|
|
|
|
#include <sys/mman.h>
|
2005-05-19 11:36:44 +02:00
|
|
|
#include "../../kernel/const.h"
|
2005-07-14 17:15:18 +02:00
|
|
|
#include "../../kernel/config.h"
|
2005-05-19 11:36:44 +02:00
|
|
|
#include "../../kernel/type.h"
|
2005-04-21 16:53:53 +02:00
|
|
|
|
2005-09-30 14:57:30 +02:00
|
|
|
#include <sys/vm.h>
|
2008-11-19 13:26:10 +01:00
|
|
|
#include <sys/vm_i386.h>
|
2005-09-30 14:57:30 +02:00
|
|
|
|
2005-07-18 17:40:24 +02:00
|
|
|
#include "assert.h"
|
|
|
|
|
2006-02-15 12:18:21 +01:00
|
|
|
#include "local.h"
|
|
|
|
|
2009-03-19 14:48:19 +01:00
|
|
|
/* ramdisks (/dev/ram*) */
|
|
|
|
#define RAMDISKS 6
|
|
|
|
|
|
|
|
#define RAM_DEV_LAST (RAM_DEV_FIRST+RAMDISKS-1)
|
|
|
|
|
|
|
|
#define NR_DEVS (7+RAMDISKS) /* number of minor devices */
|
2005-04-21 16:53:53 +02:00
|
|
|
|
2005-04-29 17:36:43 +02:00
|
|
|
PRIVATE struct device m_geom[NR_DEVS]; /* base and size of each device */
|
2008-12-11 18:33:13 +01:00
|
|
|
PRIVATE vir_bytes m_vaddrs[NR_DEVS];
|
2005-04-21 16:53:53 +02:00
|
|
|
PRIVATE int m_device; /* current device */
|
2005-06-03 15:55:06 +02:00
|
|
|
PRIVATE struct kinfo kinfo; /* kernel information */
|
|
|
|
|
|
|
|
extern int errno; /* error number for PM calls */
|
2005-04-21 16:53:53 +02:00
|
|
|
|
2009-09-22 15:57:21 +02:00
|
|
|
PRIVATE int openct[NR_DEVS];
|
|
|
|
|
2005-09-11 19:09:11 +02:00
|
|
|
FORWARD _PROTOTYPE( char *m_name, (void) );
|
|
|
|
FORWARD _PROTOTYPE( struct device *m_prepare, (int device) );
|
2009-12-02 10:57:48 +01:00
|
|
|
FORWARD _PROTOTYPE( int m_transfer, (int proc_nr, int opcode,
|
|
|
|
u64_t position, iovec_t *iov, unsigned nr_req) );
|
2005-09-11 19:09:11 +02:00
|
|
|
FORWARD _PROTOTYPE( int m_do_open, (struct driver *dp, message *m_ptr) );
|
2009-09-22 15:57:21 +02:00
|
|
|
FORWARD _PROTOTYPE( int m_do_close, (struct driver *dp, message *m_ptr) );
|
2005-04-21 16:53:53 +02:00
|
|
|
FORWARD _PROTOTYPE( void m_init, (void) );
|
2009-12-02 10:57:48 +01:00
|
|
|
FORWARD _PROTOTYPE( int m_ioctl, (struct driver *dp, message *m_ptr) );
|
2005-09-11 19:09:11 +02:00
|
|
|
FORWARD _PROTOTYPE( void m_geometry, (struct partition *entry) );
|
2005-04-21 16:53:53 +02:00
|
|
|
|
|
|
|
/* Entry points to this driver. */
|
|
|
|
PRIVATE struct driver m_dtab = {
|
|
|
|
m_name, /* current device's name */
|
|
|
|
m_do_open, /* open or mount */
|
2009-09-22 15:57:21 +02:00
|
|
|
m_do_close, /* nothing on a close */
|
2005-04-21 16:53:53 +02:00
|
|
|
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" */
|
2005-07-26 14:50:25 +02:00
|
|
|
nop_signal, /* system signals */
|
2005-08-03 17:22:41 +02:00
|
|
|
nop_alarm,
|
2005-07-08 19:23:44 +02:00
|
|
|
nop_cancel,
|
|
|
|
nop_select,
|
2005-08-25 10:19:11 +02:00
|
|
|
NULL,
|
2005-07-08 19:23:44 +02:00
|
|
|
NULL
|
2005-04-21 16:53:53 +02:00
|
|
|
};
|
|
|
|
|
2005-04-29 17:36:43 +02:00
|
|
|
/* Buffer for the /dev/zero null byte feed. */
|
|
|
|
#define ZERO_BUF_SIZE 1024
|
2005-06-03 15:55:06 +02:00
|
|
|
PRIVATE char dev_zero[ZERO_BUF_SIZE];
|
2005-04-29 17:36:43 +02:00
|
|
|
|
2005-05-19 11:36:44 +02:00
|
|
|
#define click_to_round_k(n) \
|
|
|
|
((unsigned) ((((unsigned long) (n) << CLICK_SHIFT) + 512) / 1024))
|
|
|
|
|
Basic System Event Framework (SEF) with ping and live update.
SYSLIB CHANGES:
- SEF must be used by every system process and is thereby part of the system
library.
- The framework provides a receive() interface (sef_receive) for system
processes to automatically catch known system even messages and process them.
- SEF provides a default behavior for each type of system event, but allows
system processes to register callbacks to override the default behavior.
- Custom (local to the process) or predefined (provided by SEF) callback
implementations can be registered to SEF.
- SEF currently includes support for 2 types of system events:
1. SEF Ping. The event occurs every time RS sends a ping to figure out
whether a system process is still alive. The default callback implementation
provided by SEF is to notify RS back to let it know the process is alive
and kicking.
2. SEF Live update. The event occurs every time RS sends a prepare to update
message to let a system process know an update is available and to prepare
for it. The live update support is very basic for now. SEF only deals with
verifying if the prepare state can be supported by the process, dumping the
state for debugging purposes, and providing an event-driven programming
model to the process to react to state changes check-in when ready to update.
- SEF should be extended in the future to integrate support for more types of
system events. Ideally, all the cross-cutting concerns should be integrated into
SEF to avoid duplicating code and ease extensibility. Examples include:
* PM notify messages primarily used at shutdown.
* SYSTEM notify messages primarily used for signals.
* CLOCK notify messages used for system alarms.
* Debug messages. IS could still be in charge of fkey handling but would
forward the debug message to the target process (e.g. PM, if the user
requested debug information about PM). SEF would then catch the message and
do nothing unless the process has registered an appropriate callback to
deal with the event. This simplifies the programming model to print debug
information, avoids duplicating code, and reduces the effort to print
debug information.
SYSTEM PROCESSES CHANGES:
- Every system process registers SEF callbacks it needs to override the default
system behavior and calls sef_startup() right after being started.
- sef_startup() does almost nothing now, but will be extended in the future to
support callbacks of its own to let RS control and synchronize with every
system process at initialization time.
- Every system process calls sef_receive() now rather than receive() directly,
to let SEF handle predefined system events.
RS CHANGES:
- RS supports a basic single-component live update protocol now, as follows:
* When an update command is issued (via "service update *"), RS notifies the
target system process to prepare for a specific update state.
* If the process doesn't respond back in time, the update is aborted.
* When the process responds back, RS kills it and marks it for refreshing.
* The process is then automatically restarted as for a buggy process and can
start running again.
* Live update is currently prototyped as a controlled failure.
2009-12-21 15:12:21 +01:00
|
|
|
/* SEF functions and variables. */
|
|
|
|
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
|
|
|
|
|
2005-04-21 16:53:53 +02:00
|
|
|
/*===========================================================================*
|
|
|
|
* main *
|
|
|
|
*===========================================================================*/
|
2005-08-25 14:35:59 +02:00
|
|
|
PUBLIC int main(void)
|
2005-04-21 16:53:53 +02:00
|
|
|
{
|
2005-08-05 11:43:22 +02:00
|
|
|
/* Main program. Initialize the memory driver and start the main loop. */
|
2006-01-17 18:43:35 +01:00
|
|
|
struct sigaction sa;
|
|
|
|
|
Basic System Event Framework (SEF) with ping and live update.
SYSLIB CHANGES:
- SEF must be used by every system process and is thereby part of the system
library.
- The framework provides a receive() interface (sef_receive) for system
processes to automatically catch known system even messages and process them.
- SEF provides a default behavior for each type of system event, but allows
system processes to register callbacks to override the default behavior.
- Custom (local to the process) or predefined (provided by SEF) callback
implementations can be registered to SEF.
- SEF currently includes support for 2 types of system events:
1. SEF Ping. The event occurs every time RS sends a ping to figure out
whether a system process is still alive. The default callback implementation
provided by SEF is to notify RS back to let it know the process is alive
and kicking.
2. SEF Live update. The event occurs every time RS sends a prepare to update
message to let a system process know an update is available and to prepare
for it. The live update support is very basic for now. SEF only deals with
verifying if the prepare state can be supported by the process, dumping the
state for debugging purposes, and providing an event-driven programming
model to the process to react to state changes check-in when ready to update.
- SEF should be extended in the future to integrate support for more types of
system events. Ideally, all the cross-cutting concerns should be integrated into
SEF to avoid duplicating code and ease extensibility. Examples include:
* PM notify messages primarily used at shutdown.
* SYSTEM notify messages primarily used for signals.
* CLOCK notify messages used for system alarms.
* Debug messages. IS could still be in charge of fkey handling but would
forward the debug message to the target process (e.g. PM, if the user
requested debug information about PM). SEF would then catch the message and
do nothing unless the process has registered an appropriate callback to
deal with the event. This simplifies the programming model to print debug
information, avoids duplicating code, and reduces the effort to print
debug information.
SYSTEM PROCESSES CHANGES:
- Every system process registers SEF callbacks it needs to override the default
system behavior and calls sef_startup() right after being started.
- sef_startup() does almost nothing now, but will be extended in the future to
support callbacks of its own to let RS control and synchronize with every
system process at initialization time.
- Every system process calls sef_receive() now rather than receive() directly,
to let SEF handle predefined system events.
RS CHANGES:
- RS supports a basic single-component live update protocol now, as follows:
* When an update command is issued (via "service update *"), RS notifies the
target system process to prepare for a specific update state.
* If the process doesn't respond back in time, the update is aborted.
* When the process responds back, RS kills it and marks it for refreshing.
* The process is then automatically restarted as for a buggy process and can
start running again.
* Live update is currently prototyped as a controlled failure.
2009-12-21 15:12:21 +01:00
|
|
|
/* SEF local startup. */
|
|
|
|
sef_local_startup();
|
|
|
|
|
2006-01-17 18:43:35 +01:00
|
|
|
sa.sa_handler = SIG_MESS;
|
|
|
|
sigemptyset(&sa.sa_mask);
|
|
|
|
sa.sa_flags = 0;
|
|
|
|
if (sigaction(SIGTERM,&sa,NULL)<0) panic("MEM","sigaction failed", errno);
|
|
|
|
|
2009-12-02 10:57:48 +01:00
|
|
|
m_init();
|
|
|
|
driver_task(&m_dtab, DRIVER_STD);
|
|
|
|
return(OK);
|
2005-04-21 16:53:53 +02:00
|
|
|
}
|
|
|
|
|
Basic System Event Framework (SEF) with ping and live update.
SYSLIB CHANGES:
- SEF must be used by every system process and is thereby part of the system
library.
- The framework provides a receive() interface (sef_receive) for system
processes to automatically catch known system even messages and process them.
- SEF provides a default behavior for each type of system event, but allows
system processes to register callbacks to override the default behavior.
- Custom (local to the process) or predefined (provided by SEF) callback
implementations can be registered to SEF.
- SEF currently includes support for 2 types of system events:
1. SEF Ping. The event occurs every time RS sends a ping to figure out
whether a system process is still alive. The default callback implementation
provided by SEF is to notify RS back to let it know the process is alive
and kicking.
2. SEF Live update. The event occurs every time RS sends a prepare to update
message to let a system process know an update is available and to prepare
for it. The live update support is very basic for now. SEF only deals with
verifying if the prepare state can be supported by the process, dumping the
state for debugging purposes, and providing an event-driven programming
model to the process to react to state changes check-in when ready to update.
- SEF should be extended in the future to integrate support for more types of
system events. Ideally, all the cross-cutting concerns should be integrated into
SEF to avoid duplicating code and ease extensibility. Examples include:
* PM notify messages primarily used at shutdown.
* SYSTEM notify messages primarily used for signals.
* CLOCK notify messages used for system alarms.
* Debug messages. IS could still be in charge of fkey handling but would
forward the debug message to the target process (e.g. PM, if the user
requested debug information about PM). SEF would then catch the message and
do nothing unless the process has registered an appropriate callback to
deal with the event. This simplifies the programming model to print debug
information, avoids duplicating code, and reduces the effort to print
debug information.
SYSTEM PROCESSES CHANGES:
- Every system process registers SEF callbacks it needs to override the default
system behavior and calls sef_startup() right after being started.
- sef_startup() does almost nothing now, but will be extended in the future to
support callbacks of its own to let RS control and synchronize with every
system process at initialization time.
- Every system process calls sef_receive() now rather than receive() directly,
to let SEF handle predefined system events.
RS CHANGES:
- RS supports a basic single-component live update protocol now, as follows:
* When an update command is issued (via "service update *"), RS notifies the
target system process to prepare for a specific update state.
* If the process doesn't respond back in time, the update is aborted.
* When the process responds back, RS kills it and marks it for refreshing.
* The process is then automatically restarted as for a buggy process and can
start running again.
* Live update is currently prototyped as a controlled failure.
2009-12-21 15:12:21 +01:00
|
|
|
/*===========================================================================*
|
|
|
|
* sef_local_startup *
|
|
|
|
*===========================================================================*/
|
|
|
|
PRIVATE void sef_local_startup()
|
|
|
|
{
|
|
|
|
/* 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();
|
|
|
|
}
|
|
|
|
|
2005-04-21 16:53:53 +02:00
|
|
|
/*===========================================================================*
|
|
|
|
* 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 *
|
|
|
|
*===========================================================================*/
|
2009-12-02 10:57:48 +01:00
|
|
|
PRIVATE int m_transfer(proc_nr, opcode, pos64, iov, nr_req)
|
2005-04-21 16:53:53 +02:00
|
|
|
int proc_nr; /* process doing the request */
|
2007-02-07 17:22:19 +01:00
|
|
|
int opcode; /* DEV_GATHER_S or DEV_SCATTER_S */
|
2006-11-27 15:21:43 +01:00
|
|
|
u64_t pos64; /* offset on device to read or write */
|
2005-04-21 16:53:53 +02:00
|
|
|
iovec_t *iov; /* pointer to read or write request vector */
|
|
|
|
unsigned nr_req; /* length of request vector */
|
|
|
|
{
|
2005-05-19 11:36:44 +02:00
|
|
|
/* Read or write one the driver's minor devices. */
|
2005-04-29 17:36:43 +02:00
|
|
|
unsigned count, left, chunk;
|
2006-06-20 10:56:15 +02:00
|
|
|
vir_bytes user_vir, vir_offset = 0;
|
2005-04-21 16:53:53 +02:00
|
|
|
struct device *dv;
|
|
|
|
unsigned long dv_size;
|
2006-06-20 10:56:15 +02:00
|
|
|
int s, r;
|
2006-11-27 15:21:43 +01:00
|
|
|
off_t position;
|
2008-12-11 18:33:13 +01:00
|
|
|
vir_bytes dev_vaddr;
|
2006-06-20 10:56:15 +02:00
|
|
|
|
2007-04-24 15:27:33 +02:00
|
|
|
/* ZERO_DEV and NULL_DEV are infinite in size. */
|
|
|
|
if (m_device != ZERO_DEV && m_device != NULL_DEV && ex64hi(pos64) != 0)
|
2006-11-27 15:21:43 +01:00
|
|
|
return OK; /* Beyond EOF */
|
|
|
|
position= cv64ul(pos64);
|
|
|
|
|
2005-04-21 16:53:53 +02:00
|
|
|
/* Get minor device number and check for /dev/null. */
|
2005-05-19 11:36:44 +02:00
|
|
|
dv = &m_geom[m_device];
|
2005-04-21 16:53:53 +02:00
|
|
|
dv_size = cv64ul(dv->dv_size);
|
2008-12-11 18:33:13 +01:00
|
|
|
dev_vaddr = m_vaddrs[m_device];
|
2005-04-21 16:53:53 +02:00
|
|
|
|
|
|
|
while (nr_req > 0) {
|
2005-04-29 17:36:43 +02:00
|
|
|
|
|
|
|
/* How much to transfer and where to / from. */
|
2005-04-21 16:53:53 +02:00
|
|
|
count = iov->iov_size;
|
|
|
|
user_vir = iov->iov_addr;
|
|
|
|
|
2005-05-19 11:36:44 +02:00
|
|
|
switch (m_device) {
|
2005-04-29 17:36:43 +02:00
|
|
|
|
|
|
|
/* No copying; ignore request. */
|
2005-04-21 16:53:53 +02:00
|
|
|
case NULL_DEV:
|
2007-02-07 17:22:19 +01:00
|
|
|
if (opcode == DEV_GATHER_S) return(OK); /* always at EOF */
|
2005-04-21 16:53:53 +02:00
|
|
|
break;
|
|
|
|
|
2009-03-19 14:48:19 +01:00
|
|
|
/* Virtual copying. For RAM disks, kernel memory and internal FS. */
|
|
|
|
default:
|
2005-04-29 17:36:43 +02:00
|
|
|
case KMEM_DEV:
|
2009-03-19 14:48:19 +01:00
|
|
|
case RAM_DEV_OLD:
|
2008-12-11 18:33:13 +01:00
|
|
|
case IMGRD_DEV:
|
2009-03-19 14:48:19 +01:00
|
|
|
/* Bogus number. */
|
|
|
|
if(m_device < 0 || m_device >= NR_DEVS) {
|
|
|
|
return(EINVAL);
|
|
|
|
}
|
2008-12-11 18:33:13 +01:00
|
|
|
if(!dev_vaddr || dev_vaddr == (vir_bytes) MAP_FAILED) {
|
|
|
|
printf("MEM: dev %d not initialized\n", m_device);
|
|
|
|
return EIO;
|
|
|
|
}
|
2005-04-29 17:36:43 +02:00
|
|
|
if (position >= dv_size) return(OK); /* check for EOF */
|
|
|
|
if (position + count > dv_size) count = dv_size - position;
|
2008-12-11 18:33:13 +01:00
|
|
|
if (opcode == DEV_GATHER_S) { /* copy actual data */
|
2006-06-20 10:56:15 +02:00
|
|
|
r=sys_safecopyto(proc_nr, user_vir, vir_offset,
|
2008-12-11 18:33:13 +01:00
|
|
|
dev_vaddr + position, count, D);
|
2005-04-29 17:36:43 +02:00
|
|
|
} else {
|
2006-06-20 10:56:15 +02:00
|
|
|
r=sys_safecopyfrom(proc_nr, user_vir, vir_offset,
|
2008-12-11 18:33:13 +01:00
|
|
|
dev_vaddr + position, count, D);
|
2006-06-20 10:56:15 +02:00
|
|
|
}
|
|
|
|
if(r != OK) {
|
|
|
|
panic("MEM","I/O copy failed",r);
|
2005-04-29 17:36:43 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2007-03-09 17:03:19 +01:00
|
|
|
/* Physical copying. Only used to access entire memory.
|
|
|
|
* Transfer one 'page window' at a time.
|
|
|
|
*/
|
2005-04-29 17:36:43 +02:00
|
|
|
case MEM_DEV:
|
2007-03-09 17:03:19 +01:00
|
|
|
{
|
|
|
|
u32_t pagestart, page_off;
|
|
|
|
static u32_t pagestart_mapped;
|
|
|
|
static int any_mapped = 0;
|
2008-12-11 15:42:23 +01:00
|
|
|
static char *vaddr;
|
2007-03-09 17:03:19 +01:00
|
|
|
int r;
|
|
|
|
u32_t subcount;
|
2008-12-11 18:33:13 +01:00
|
|
|
phys_bytes mem_phys;
|
2007-03-09 17:03:19 +01:00
|
|
|
|
|
|
|
if (position >= dv_size)
|
2007-02-16 16:57:05 +01:00
|
|
|
return(OK); /* check for EOF */
|
2007-03-09 17:03:19 +01:00
|
|
|
if (position + count > dv_size)
|
2007-02-16 16:57:05 +01:00
|
|
|
count = dv_size - position;
|
2008-12-11 18:33:13 +01:00
|
|
|
mem_phys = position;
|
2007-03-09 17:03:19 +01:00
|
|
|
|
2008-11-19 13:26:10 +01:00
|
|
|
page_off = mem_phys % I386_PAGE_SIZE;
|
2007-03-09 17:03:19 +01:00
|
|
|
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) {
|
2008-12-11 15:42:23 +01:00
|
|
|
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");
|
2007-03-09 17:03:19 +01:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
any_mapped = 1;
|
|
|
|
pagestart_mapped = pagestart;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* how much to be done within this page. */
|
2008-11-19 13:26:10 +01:00
|
|
|
subcount = I386_PAGE_SIZE-page_off;
|
2007-03-09 17:03:19 +01:00
|
|
|
if(subcount > count)
|
|
|
|
subcount = count;
|
2005-04-21 16:53:53 +02:00
|
|
|
|
2007-02-07 17:22:19 +01:00
|
|
|
if (opcode == DEV_GATHER_S) { /* copy data */
|
2007-03-09 17:03:19 +01:00
|
|
|
s=sys_safecopyto(proc_nr, user_vir,
|
2008-12-11 15:42:23 +01:00
|
|
|
vir_offset, (vir_bytes) vaddr+page_off, subcount, D);
|
2005-04-21 16:53:53 +02:00
|
|
|
} else {
|
2007-03-09 17:03:19 +01:00
|
|
|
s=sys_safecopyfrom(proc_nr, user_vir,
|
2008-12-11 15:42:23 +01:00
|
|
|
vir_offset, (vir_bytes) vaddr+page_off, subcount, D);
|
2005-04-21 16:53:53 +02:00
|
|
|
}
|
2007-03-09 17:03:19 +01:00
|
|
|
if(s != OK)
|
|
|
|
return s;
|
|
|
|
count = subcount;
|
2005-04-29 17:36:43 +02:00
|
|
|
break;
|
2007-03-09 17:03:19 +01:00
|
|
|
}
|
2005-04-29 17:36:43 +02:00
|
|
|
|
|
|
|
/* Null byte stream generator. */
|
|
|
|
case ZERO_DEV:
|
2007-02-07 17:22:19 +01:00
|
|
|
if (opcode == DEV_GATHER_S) {
|
2006-06-20 10:56:15 +02:00
|
|
|
size_t suboffset = 0;
|
2005-04-29 17:36:43 +02:00
|
|
|
left = count;
|
|
|
|
while (left > 0) {
|
|
|
|
chunk = (left > ZERO_BUF_SIZE) ? ZERO_BUF_SIZE : left;
|
2006-06-20 10:56:15 +02:00
|
|
|
s=sys_safecopyto(proc_nr, user_vir,
|
|
|
|
vir_offset+suboffset, (vir_bytes) dev_zero, chunk, D);
|
|
|
|
if(s != OK)
|
2007-03-09 17:03:19 +01:00
|
|
|
report("MEM","sys_safecopyto failed", s);
|
2005-04-29 17:36:43 +02:00
|
|
|
left -= chunk;
|
2006-06-20 10:56:15 +02:00
|
|
|
suboffset += chunk;
|
2005-04-29 17:36:43 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2005-04-21 16:53:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Book the number of bytes transferred. */
|
|
|
|
position += count;
|
2006-06-20 10:56:15 +02:00
|
|
|
vir_offset += count;
|
|
|
|
if ((iov->iov_size -= count) == 0) { iov++; nr_req--; vir_offset = 0; }
|
2005-04-29 17:36:43 +02:00
|
|
|
|
2005-04-21 16:53:53 +02:00
|
|
|
}
|
|
|
|
return(OK);
|
|
|
|
}
|
|
|
|
|
2005-09-11 19:09:11 +02:00
|
|
|
/*===========================================================================*
|
|
|
|
* m_do_open *
|
|
|
|
*===========================================================================*/
|
2005-04-21 16:53:53 +02:00
|
|
|
PRIVATE int m_do_open(dp, m_ptr)
|
|
|
|
struct driver *dp;
|
|
|
|
message *m_ptr;
|
|
|
|
{
|
2005-11-04 18:16:54 +01:00
|
|
|
int r;
|
|
|
|
|
2005-10-20 22:26:02 +02:00
|
|
|
/* Check device number on open. */
|
2005-04-21 16:53:53 +02:00
|
|
|
if (m_prepare(m_ptr->DEVICE) == NIL_DEV) return(ENXIO);
|
2005-11-04 18:16:54 +01:00
|
|
|
if (m_device == MEM_DEV)
|
|
|
|
{
|
2006-03-03 11:21:45 +01:00
|
|
|
r = sys_enable_iop(m_ptr->IO_ENDPT);
|
2005-11-04 18:16:54 +01:00
|
|
|
if (r != OK)
|
|
|
|
{
|
|
|
|
printf("m_do_open: sys_enable_iop failed for %d: %d\n",
|
2006-03-03 11:21:45 +01:00
|
|
|
m_ptr->IO_ENDPT, r);
|
2005-11-04 18:16:54 +01:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
}
|
2009-09-22 15:57:21 +02:00
|
|
|
|
|
|
|
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]--;
|
|
|
|
|
2005-04-21 16:53:53 +02:00
|
|
|
return(OK);
|
|
|
|
}
|
|
|
|
|
2009-09-22 15:57:21 +02:00
|
|
|
|
2005-04-21 16:53:53 +02:00
|
|
|
/*===========================================================================*
|
|
|
|
* m_init *
|
|
|
|
*===========================================================================*/
|
|
|
|
PRIVATE void m_init()
|
|
|
|
{
|
2005-04-29 17:36:43 +02:00
|
|
|
/* Initialize this task. All minor devices are initialized one by one. */
|
2006-07-13 16:50:23 +02:00
|
|
|
u32_t ramdev_size;
|
2005-05-19 11:36:44 +02:00
|
|
|
int i, s;
|
2005-04-21 16:53:53 +02:00
|
|
|
|
2005-04-29 17:36:43 +02:00
|
|
|
if (OK != (s=sys_getkinfo(&kinfo))) {
|
2005-06-01 16:31:00 +02:00
|
|
|
panic("MEM","Couldn't get kernel information.",s);
|
2005-04-21 16:53:53 +02:00
|
|
|
}
|
2005-04-22 15:25:17 +02:00
|
|
|
|
2008-11-19 13:26:10 +01:00
|
|
|
#if 0
|
2008-12-11 18:33:13 +01:00
|
|
|
/* Map in kernel memory for /dev/kmem. */
|
2005-04-29 17:36:43 +02:00
|
|
|
m_geom[KMEM_DEV].dv_base = cvul64(kinfo.kmem_base);
|
|
|
|
m_geom[KMEM_DEV].dv_size = cvul64(kinfo.kmem_size);
|
2008-12-11 18:33:13 +01:00
|
|
|
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.");
|
2005-04-29 17:36:43 +02:00
|
|
|
}
|
2008-11-19 13:26:10 +01:00
|
|
|
#endif
|
2005-04-29 17:36:43 +02:00
|
|
|
|
2006-02-15 12:18:21 +01:00
|
|
|
/* Ramdisk image built into the memory driver */
|
|
|
|
m_geom[IMGRD_DEV].dv_base= cvul64(0);
|
|
|
|
m_geom[IMGRD_DEV].dv_size= cvul64(imgrd_size);
|
2008-12-11 18:33:13 +01:00
|
|
|
m_vaddrs[IMGRD_DEV] = (vir_bytes) imgrd;
|
2006-02-15 12:18:21 +01:00
|
|
|
|
2005-06-03 15:55:06 +02:00
|
|
|
/* Initialize /dev/zero. Simply write zeros into the buffer. */
|
2005-04-29 17:36:43 +02:00
|
|
|
for (i=0; i<ZERO_BUF_SIZE; i++) {
|
2005-06-03 15:55:06 +02:00
|
|
|
dev_zero[i] = '\0';
|
2005-04-29 17:36:43 +02:00
|
|
|
}
|
|
|
|
|
2009-09-22 15:57:21 +02:00
|
|
|
for(i = 0; i < NR_DEVS; i++)
|
|
|
|
openct[i] = 0;
|
|
|
|
|
2007-02-16 16:57:05 +01:00
|
|
|
/* Set up memory range for /dev/mem. */
|
2008-12-11 18:33:13 +01:00
|
|
|
m_geom[MEM_DEV].dv_base = cvul64(0);
|
2007-03-09 17:03:19 +01:00
|
|
|
m_geom[MEM_DEV].dv_size = cvul64(0xffffffff);
|
2008-12-11 18:33:13 +01:00
|
|
|
|
|
|
|
m_vaddrs[MEM_DEV] = (vir_bytes) MAP_FAILED; /* we are not mapping this in. */
|
2005-04-21 16:53:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*===========================================================================*
|
|
|
|
* m_ioctl *
|
|
|
|
*===========================================================================*/
|
2009-12-02 10:57:48 +01:00
|
|
|
PRIVATE int m_ioctl(dp, m_ptr)
|
2005-05-19 11:36:44 +02:00
|
|
|
struct driver *dp; /* pointer to driver structure */
|
|
|
|
message *m_ptr; /* pointer to control message */
|
2005-04-21 16:53:53 +02:00
|
|
|
{
|
2005-05-19 11:36:44 +02:00
|
|
|
/* I/O controls for the memory driver. Currently there is one I/O control:
|
|
|
|
* - MIOCRAMSIZE: to set the size of the RAM disk.
|
|
|
|
*/
|
2005-04-21 16:53:53 +02:00
|
|
|
struct device *dv;
|
|
|
|
|
|
|
|
switch (m_ptr->REQUEST) {
|
|
|
|
case MIOCRAMSIZE: {
|
2006-02-15 12:18:21 +01:00
|
|
|
/* Someone wants to create a new RAM disk with the given size. */
|
|
|
|
u32_t ramdev_size;
|
2009-03-19 14:48:19 +01:00
|
|
|
int s, dev;
|
|
|
|
void *mem;
|
2005-04-21 16:53:53 +02:00
|
|
|
|
2006-02-15 12:18:21 +01:00
|
|
|
/* A ramdisk can be created only once, and only on RAM disk device. */
|
2009-03-19 14:48:19 +01:00
|
|
|
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);
|
2005-04-21 16:53:53 +02:00
|
|
|
|
2006-02-15 12:18:21 +01:00
|
|
|
/* Get request structure */
|
2006-06-20 10:56:15 +02:00
|
|
|
s= sys_safecopyfrom(m_ptr->IO_ENDPT, (vir_bytes)m_ptr->IO_GRANT,
|
|
|
|
0, (vir_bytes)&ramdev_size, sizeof(ramdev_size), D);
|
2006-02-15 12:18:21 +01:00
|
|
|
if (s != OK)
|
|
|
|
return s;
|
2009-03-19 14:48:19 +01:00
|
|
|
if(m_vaddrs[dev] && !cmp64(dv->dv_size, cvul64(ramdev_size))) {
|
|
|
|
return(OK);
|
|
|
|
}
|
2009-09-22 15:57:21 +02:00
|
|
|
/* openct is 1 for the ioctl(). */
|
|
|
|
if(openct[dev] != 1) {
|
|
|
|
printf("MEM: MIOCRAMSIZE: %d in use (count %d)\n",
|
|
|
|
dev, openct[dev]);
|
|
|
|
return(EBUSY);
|
|
|
|
}
|
2009-03-19 14:48:19 +01:00
|
|
|
if(m_vaddrs[dev]) {
|
2009-09-22 15:57:21 +02:00
|
|
|
u32_t size;
|
|
|
|
if(ex64hi(dv->dv_size)) {
|
|
|
|
panic("MEM","huge old ramdisk", NO_NUM);
|
|
|
|
}
|
|
|
|
size = ex64lo(dv->dv_size);
|
|
|
|
munmap((void *) m_vaddrs[dev], size);
|
|
|
|
m_vaddrs[dev] = (vir_bytes) NULL;
|
2009-03-19 14:48:19 +01:00
|
|
|
}
|
2006-03-13 16:41:07 +01:00
|
|
|
|
|
|
|
#if DEBUG
|
2009-03-19 14:48:19 +01:00
|
|
|
printf("MEM:%d: allocating ramdisk of size 0x%x\n", dev, ramdev_size);
|
2006-03-13 16:41:07 +01:00
|
|
|
#endif
|
2006-02-15 12:18:21 +01:00
|
|
|
|
2005-04-29 17:36:43 +02:00
|
|
|
/* Try to allocate a piece of memory for the RAM disk. */
|
2009-09-21 16:25:54 +02:00
|
|
|
if((mem = mmap(0, ramdev_size, PROT_READ|PROT_WRITE,
|
|
|
|
MAP_PREALLOC|MAP_ANON, -1, 0)) == MAP_FAILED) {
|
2008-12-11 18:33:13 +01:00
|
|
|
printf("MEM: failed to get memory for ramdisk\n");
|
2005-06-06 11:30:44 +02:00
|
|
|
return(ENOMEM);
|
2008-12-11 18:33:13 +01:00
|
|
|
}
|
2005-10-20 22:26:02 +02:00
|
|
|
|
2009-03-19 14:48:19 +01:00
|
|
|
m_vaddrs[dev] = (vir_bytes) mem;
|
|
|
|
|
2005-10-20 22:26:02 +02:00
|
|
|
dv->dv_size = cvul64(ramdev_size);
|
2009-03-19 14:48:19 +01:00
|
|
|
|
2005-04-21 16:53:53 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
2009-12-02 10:57:48 +01:00
|
|
|
return(do_diocntl(&m_dtab, m_ptr));
|
2005-04-21 16:53:53 +02:00
|
|
|
}
|
|
|
|
return(OK);
|
|
|
|
}
|
|
|
|
|
2005-09-11 19:09:11 +02:00
|
|
|
/*===========================================================================*
|
|
|
|
* m_geometry *
|
|
|
|
*===========================================================================*/
|
2005-04-21 16:53:53 +02:00
|
|
|
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;
|
|
|
|
}
|
Basic System Event Framework (SEF) with ping and live update.
SYSLIB CHANGES:
- SEF must be used by every system process and is thereby part of the system
library.
- The framework provides a receive() interface (sef_receive) for system
processes to automatically catch known system even messages and process them.
- SEF provides a default behavior for each type of system event, but allows
system processes to register callbacks to override the default behavior.
- Custom (local to the process) or predefined (provided by SEF) callback
implementations can be registered to SEF.
- SEF currently includes support for 2 types of system events:
1. SEF Ping. The event occurs every time RS sends a ping to figure out
whether a system process is still alive. The default callback implementation
provided by SEF is to notify RS back to let it know the process is alive
and kicking.
2. SEF Live update. The event occurs every time RS sends a prepare to update
message to let a system process know an update is available and to prepare
for it. The live update support is very basic for now. SEF only deals with
verifying if the prepare state can be supported by the process, dumping the
state for debugging purposes, and providing an event-driven programming
model to the process to react to state changes check-in when ready to update.
- SEF should be extended in the future to integrate support for more types of
system events. Ideally, all the cross-cutting concerns should be integrated into
SEF to avoid duplicating code and ease extensibility. Examples include:
* PM notify messages primarily used at shutdown.
* SYSTEM notify messages primarily used for signals.
* CLOCK notify messages used for system alarms.
* Debug messages. IS could still be in charge of fkey handling but would
forward the debug message to the target process (e.g. PM, if the user
requested debug information about PM). SEF would then catch the message and
do nothing unless the process has registered an appropriate callback to
deal with the event. This simplifies the programming model to print debug
information, avoids duplicating code, and reduces the effort to print
debug information.
SYSTEM PROCESSES CHANGES:
- Every system process registers SEF callbacks it needs to override the default
system behavior and calls sef_startup() right after being started.
- sef_startup() does almost nothing now, but will be extended in the future to
support callbacks of its own to let RS control and synchronize with every
system process at initialization time.
- Every system process calls sef_receive() now rather than receive() directly,
to let SEF handle predefined system events.
RS CHANGES:
- RS supports a basic single-component live update protocol now, as follows:
* When an update command is issued (via "service update *"), RS notifies the
target system process to prepare for a specific update state.
* If the process doesn't respond back in time, the update is aborted.
* When the process responds back, RS kills it and marks it for refreshing.
* The process is then automatically restarted as for a buggy process and can
start running again.
* Live update is currently prototyped as a controlled failure.
2009-12-21 15:12:21 +01:00
|
|
|
|