Minix/minix
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Upgrade libddekit and introduce devmand.

Browse Source 
Devmand (Device manager daemon) is the daemon that will
dynamically manage services based on events received from
the system.
This commit is contained in:
Kees Jongenburger
2012-06-05 09:43:18 +00:00
parent 6b8821515d
commit ade7dc8ded
16 changed files with 1219 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
lib/libddekit/src/dde.c
View File

@@ -30,7 +30,7 @@ static void ddekit_dispatcher_thread_init(void);
/****************************************************************************/
static void dispatcher_thread(void *unused) {
/*
/*
* Gets all messages and dispatches them.
*
* NOTE: this thread runs only when no other ddekit is
@@ -40,6 +40,7 @@ static void dispatcher_thread(void *unused) {
message m;
int r;
int i;
int ipc_status;
_ddekit_thread_set_myprio(0);
@@ -47,17 +48,17 @@ static void dispatcher_thread(void *unused) {
/* Trigger a timer interrupt at each loop iteration */
_ddekit_timer_update();
/* Wait for messages */
if ((r = sef_receive(ANY, &m)) != 0) {
if ((r = sef_receive_status(ANY, &m, &ipc_status)) != 0) {
ddekit_panic("ddekit", "sef_receive failed", r);
}
_ddekit_timer_interrupt();
_ddekit_thread_wakeup_sleeping();
if (is_notify(m.m_type)) {
switch (_ENDPOINT_P(m.m_source)) {
case HARDWARE:
@@ -77,15 +78,15 @@ static void dispatcher_thread(void *unused) {
}
} else {
/*
/*
* I don't know how to handle this msg,
* but maybe we have a msg queue which can
* handle this msg.
*/
ddekit_minix_queue_msg(&m);
}
ddekit_minix_queue_msg(&m, ipc_status);
}
}
}
@@ -114,9 +115,9 @@ void ddekit_init(void)
ddekit_init_irqs();
ddekit_init_timers();
ddekit_dispatcher_thread_init();
exit_sem = ddekit_sem_init(0);
}

2
lib/libddekit/src/initcall.c
View File

@@ -8,7 +8,7 @@
#define DDEBUG DDEKIT_DEBUG_INITCALL
#endif
#include "debug.h"
#include "debug.h"
static struct __ddekit_initcall_s head = {0,0,0};

43
lib/libddekit/src/msg_queue.c
View File

@@ -19,6 +19,7 @@ struct ddekit_minix_msg_q {
unsigned from, to;
message messages[MESSAGE_QUEUE_SIZE];
int ipc_status[MESSAGE_QUEUE_SIZE];
ddekit_sem_t *msg_w_sem, *msg_r_sem;
int msg_r_pos, msg_w_pos;
@@ -26,8 +27,8 @@ struct ddekit_minix_msg_q {
};
static struct ddekit_minix_msg_q * _list = NULL;
static void _ddekit_minix_queue_msg(struct ddekit_minix_msg_q *mq,
message *m);
static void _ddekit_minix_queue_msg
(struct ddekit_minix_msg_q *mq, message *m, int ipc_status);
/*****************************************************************************
* ddekit_minix_create_msg_q *
@@ -37,7 +38,7 @@ ddekit_minix_create_msg_q(unsigned from, unsigned to)
{
struct ddekit_minix_msg_q *mq = (struct ddekit_minix_msg_q *)
ddekit_simple_malloc(sizeof(struct ddekit_minix_msg_q));
mq->from = from;
mq->to = to;
mq->msg_w_pos = 0;
@@ -49,10 +50,10 @@ ddekit_minix_create_msg_q(unsigned from, unsigned to)
/* TODO: check for overlapping message ranges */
mq->next = _list;
_list = mq;
DDEBUG_MSG_VERBOSE("created msg_q from %x to %x\n", from , to);
return mq;
return mq;
}
/*****************************************************************************
@@ -81,8 +82,12 @@ void ddekit_minix_deregister_msg_q(struct ddekit_minix_msg_q *mq)
/*****************************************************************************
* _ddekit_minix_queue_msg *
****************************************************************************/
static void
_ddekit_minix_queue_msg(struct ddekit_minix_msg_q *mq, message *m)
static void
_ddekit_minix_queue_msg (
struct ddekit_minix_msg_q *mq,
message *m,
int ipc_status
)
{
int full;
full = ddekit_sem_down_try(mq->msg_w_sem);
@@ -95,7 +100,7 @@ _ddekit_minix_queue_msg(struct ddekit_minix_msg_q *mq, message *m)
m->m_type = TASK_REPLY;
m->REP_STATUS = EAGAIN;
result = asynsend(m->m_source, m);
if (result != 0) {
ddekit_panic("unable to send reply to %d: %d\n",
m->m_source, result);
@@ -104,7 +109,7 @@ _ddekit_minix_queue_msg(struct ddekit_minix_msg_q *mq, message *m)
} else {
/* queue the message */
memcpy(&mq->messages[mq->msg_w_pos], m, sizeof(message));
mq->ipc_status[mq->msg_w_pos] = ipc_status;
if (++mq->msg_w_pos == MESSAGE_QUEUE_SIZE) {
mq->msg_w_pos = 0;
}
@@ -117,10 +122,10 @@ _ddekit_minix_queue_msg(struct ddekit_minix_msg_q *mq, message *m)
/*****************************************************************************
* ddekit_minix_queue_msg *
****************************************************************************/
void ddekit_minix_queue_msg(message *m)
void ddekit_minix_queue_msg(message *m, int ipc_status)
{
struct ddekit_minix_msg_q *it, *mq = NULL;
for (it = _list; it !=NULL ; it = it->next) {
if (m->m_type >= it->from && m->m_type <= it->to) {
mq = it;
@@ -131,25 +136,29 @@ void ddekit_minix_queue_msg(message *m)
DDEBUG_MSG_VERBOSE("no q for msgtype %x\n", m->m_type);
return;
}
_ddekit_minix_queue_msg(mq,m);
_ddekit_minix_queue_msg(mq, m, ipc_status);
}
/*****************************************************************************
* ddekit_minix_rcv *
****************************************************************************/
void ddekit_minix_rcv(struct ddekit_minix_msg_q *mq, message *m)
void ddekit_minix_rcv (
struct ddekit_minix_msg_q *mq,
message *m,
int *ipc_status
)
{
DDEBUG_MSG_VERBOSE("waiting for message");
ddekit_sem_down(mq->msg_r_sem);
memcpy(m, &mq->messages[mq->msg_r_pos], sizeof(message));
*ipc_status = mq->ipc_status[mq->msg_r_pos];
if (++mq->msg_r_pos == MESSAGE_QUEUE_SIZE) {
mq->msg_r_pos = 0;
}
DDEBUG_MSG_VERBOSE("unqueing message");
ddekit_sem_up(mq->msg_w_sem);
}

20
lib/libddekit/src/usb_client.c
View File

@@ -52,18 +52,17 @@ static void _ddekit_usb_completion(struct usb_urb *mx_urb)
if (mx_urb->type == USB_TRANSFER_ISO) {
d_urb->start_frame = mx_urb->start_frame;
memcpy(d_urb->iso_desc, mx_urb->buffer + d_urb->size,
d_urb->number_of_packets * sizeof(struct usb_iso_packet_desc));
}
memcpy(d_urb->data, mx_urb->buffer, d_urb->size);
/* free mx_urb */
ddekit_simple_free(mx_urb);
/* 'give back' URB */
d_usb_driver->completion(d_urb->priv);
}
@@ -139,11 +138,9 @@ int ddekit_usb_submit_urb(struct ddekit_usb_urb *d_urb)
{
int res;
unsigned urb_size = USB_URBSIZE(d_urb->size, d_urb->number_of_packets);
/* create mx urb out of d_urb */
struct usb_urb *mx_urb = (struct usb_urb*)
ddekit_simple_malloc(urb_size);
mx_urb->urb_size = urb_size;
mx_urb->dev_id = d_urb->dev->id;
@@ -162,18 +159,15 @@ int ddekit_usb_submit_urb(struct ddekit_usb_urb *d_urb)
if (mx_urb->type == USB_TRANSFER_ISO) {
mx_urb->number_of_packets = d_urb->number_of_packets;
mx_urb->start_frame = d_urb->start_frame;
memcpy(mx_urb->buffer + d_urb->size, d_urb->iso_desc,
d_urb->number_of_packets * sizeof(struct usb_iso_packet_desc));
}
memcpy(mx_urb->buffer, d_urb->data, d_urb->size);
d_urb->ddekit_priv = mx_urb;
/* submit mx_urb */
res = usb_send_urb(mx_urb);
return res;
}
@@ -197,14 +191,15 @@ static void _ddekit_usb_thread()
struct ddekit_minix_msg_q *mq = ddekit_minix_create_msg_q(USB_BASE,
USB_BASE + 0x1000);
message m;
int ipc_status;
while (1) {
ddekit_minix_rcv(mq, &m);
usb_handle_msg(&mx_usb_driver,&m);
ddekit_minix_rcv(mq, &m, &ipc_status);
usb_handle_msg(&mx_usb_driver, &m);
}
}
/*****************************************************************************
* ddekit_usb_init *
****************************************************************************/
@@ -213,7 +208,6 @@ int ddekit_usb_init
ddekit_usb_malloc_fn *unused,
ddekit_usb_free_fn *_unused)
{
/* start usb_thread */
d_usb_driver = drv;
usb_init("dde");

19
lib/libddekit/src/usb_server.c
View File

@@ -415,7 +415,7 @@ static void cancle_urb(message *msg)
endpoint_t ep = msg->m_source;
struct minix_usb_driver *drv;
msg->USB_RESULT = -1;
msg->m_type = USB_REPLY;
@@ -425,7 +425,7 @@ static void cancle_urb(message *msg)
return;
} else {
struct ddekit_usb_urb *d_urb = NULL;
d_urb = find_pending_urb(drv, msg->USB_URB_ID);
if (d_urb != NULL) {
@@ -436,7 +436,7 @@ static void cancle_urb(message *msg)
msg->USB_RESULT = ENODEV;
}
}
send(ep, msg);
}
@@ -468,9 +468,9 @@ static void completion_callback(void *priv)
mx_urb->actual_length = d_urb->actual_length;
mx_urb->error_count = d_urb->error_count;
mx_urb->transfer_flags = d_urb->transfer_flags;
remove_from_pending_urbs(drv, d_urb);
/* copy out URB */
res = sys_safecopyto(drv->ep, ctx->gid, 0,
(vir_bytes) ((char*)mx_urb) + sizeof(void*),
@@ -486,7 +486,7 @@ static void completion_callback(void *priv)
msg.m_type = USB_COMPLETE_URB;
msg.USB_URB_ID = ctx->urb_id;
asynsend3(drv->ep, &msg, AMF_NOREPLY);
/* free stuff */
my_free(ctx);
my_free(mx_urb);
@@ -725,10 +725,10 @@ static void devman_thread(void *unused)
{
struct ddekit_minix_msg_q *mq = ddekit_minix_create_msg_q(DEVMAN_BASE,
DEVMAN_BASE + 0xff);
int ipc_status;
message m;
while (1) {
ddekit_minix_rcv(mq, &m);
ddekit_minix_rcv(mq, &m, &ipc_status);
devman_handle_msg(&m);
}
}
@@ -742,6 +742,7 @@ static void _ddekit_usb_thread(void * unused)
USB_BASE + 0xff);
message m;
int ipc_status;
/* create devman thread */
ddekit_thread_t * dmth;
@@ -749,7 +750,7 @@ static void _ddekit_usb_thread(void * unused)
dmth = ddekit_thread_create(devman_thread, NULL, "devman_thread");
while (1) {
ddekit_minix_rcv(mq, &m);
ddekit_minix_rcv(mq, &m, &ipc_status);
handle_msg(&m);
}
}