Subversion Repositories HelenOS-historic

Compare Revisions

Ignore whitespace Rev 1572 → Rev 1573

/kernel/trunk/generic/include/ipc/ipc.h
185,9 → 185,10
IPC_PHONE_SLAMMED /**< Phone was hungup from server */
} ipc_phone_state_t;
 
/** Structure identifying phone (in TASK structure) */
struct phone_s {
SPINLOCK_DECLARE(lock);
link_t list;
link_t link;
answerbox_t *callee;
ipc_phone_state_t state;
atomic_t active_calls;
194,7 → 195,7
};
 
typedef struct {
link_t list;
link_t link;
 
int flags;
 
226,6 → 227,7
extern void ipc_cleanup(task_t *task);
extern int ipc_phone_hangup(phone_t *phone, int aggressive);
extern void ipc_backsend_err(phone_t *phone, call_t *call, __native err);
extern void ipc_print_task(task_id_t taskid);
 
extern answerbox_t *ipc_phone_0;
 
/kernel/trunk/generic/src/console/cmd.c
58,6 → 58,7
#include <proc/scheduler.h>
#include <proc/thread.h>
#include <proc/task.h>
#include <ipc/ipc.h>
 
/** Data and methods for 'help' command. */
static int cmd_help(cmd_arg_t *argv);
300,6 → 301,19
.argc = 0
};
 
/** Data and methods for 'ipc_task' command */
static int cmd_ipc_task(cmd_arg_t *argv);
static cmd_arg_t ipc_task_argv = {
.type = ARG_TYPE_INT,
};
static cmd_info_t ipc_task_info = {
.name = "ipc_task",
.description = "Show memory zone structure.",
.func = cmd_ipc_task,
.argc = 1,
.argv = &ipc_task_argv
};
 
/** Data and methods for 'zone' command */
static int cmd_zone(cmd_arg_t *argv);
static cmd_arg_t zone_argv = {
347,6 → 361,7
&exit_info,
&halt_info,
&help_info,
&ipc_task_info,
&set4_info,
&slabs_info,
&symaddr_info,
686,6 → 701,18
return 1;
}
 
/** Command for printing task ipc details
*
* @param argv Integer argument from cmdline expected
*
* return Always 1
*/
int cmd_ipc_task(cmd_arg_t * argv) {
ipc_print_task(argv[0].intval);
return 1;
}
 
 
/** Command for listing processors.
*
* @param argv Ignored.
/kernel/trunk/generic/src/proc/task.c
229,8 → 229,8
t = (task_t *) node->value[i];
spinlock_lock(&t->lock);
printf("%s: address=%#zX, taskid=%#llX, as=%#zX, ActiveCalls: %zd",
t->name, t, t->taskid, t->as, atomic_get(&t->active_calls));
printf("%s(%lld): address=%#zX, as=%#zX, ActiveCalls: %zd",
t->name, t->taskid, t, t->as, atomic_get(&t->active_calls));
for (j=0; j < IPC_MAX_PHONES; j++) {
if (t->phones[j].callee)
printf(" Ph(%zd): %#zX ", j, t->phones[j].callee);
/kernel/trunk/generic/src/ipc/ipcrsc.c
140,7 → 140,7
spinlock_lock(&TASK->answerbox.lock);
for (lst = TASK->answerbox.dispatched_calls.next;
lst != &TASK->answerbox.dispatched_calls; lst = lst->next) {
call = list_get_instance(lst, call_t, list);
call = list_get_instance(lst, call_t, link);
if ((__native)call == callid) {
result = call;
break;
177,7 → 177,6
static void phone_deallocp(phone_t *phone)
{
ASSERT(phone->state == IPC_PHONE_CONNECTING);
ASSERT(! phone->callee);
/* atomic operation */
phone->state = IPC_PHONE_FREE;
/kernel/trunk/generic/src/ipc/sysipc.c
106,7 → 106,7
spinlock_lock(&answer->data.phone->lock);
spinlock_lock(&TASK->answerbox.lock);
if (answer->data.phone->state == IPC_PHONE_CONNECTED) {
list_remove(&answer->data.phone->list);
list_remove(&answer->data.phone->link);
answer->data.phone->state = IPC_PHONE_SLAMMED;
}
spinlock_unlock(&TASK->answerbox.lock);
/kernel/trunk/generic/src/ipc/ipc.c
110,12 → 110,11
{
spinlock_lock(&phone->lock);
 
ASSERT(!phone->callee);
phone->state = IPC_PHONE_CONNECTED;
phone->callee = box;
 
spinlock_lock(&box->lock);
list_append(&phone->list, &box->connected_phones);
list_append(&phone->link, &box->connected_phones);
spinlock_unlock(&box->lock);
 
spinlock_unlock(&phone->lock);
155,7 → 154,7
call->flags |= IPC_CALL_ANSWERED;
 
spinlock_lock(&callerbox->lock);
list_append(&call->list, &callerbox->answers);
list_append(&call->link, &callerbox->answers);
spinlock_unlock(&callerbox->lock);
waitq_wakeup(&callerbox->wq, 0);
}
169,7 → 168,7
{
/* Remove from active box */
spinlock_lock(&box->lock);
list_remove(&call->list);
list_remove(&call->link);
spinlock_unlock(&box->lock);
/* Send back answer */
_ipc_answer_free_call(call);
197,7 → 196,7
}
 
spinlock_lock(&box->lock);
list_append(&call->list, &box->calls);
list_append(&call->link, &box->calls);
spinlock_unlock(&box->lock);
waitq_wakeup(&box->wq, 0);
}
261,7 → 260,7
if (phone->state != IPC_PHONE_SLAMMED) {
/* Remove myself from answerbox */
spinlock_lock(&box->lock);
list_remove(&phone->list);
list_remove(&phone->link);
spinlock_unlock(&box->lock);
 
if (phone->state != IPC_PHONE_SLAMMED) {
276,8 → 275,6
/* TODO: Do some stuff be VERY aggressive */
}
 
phone->callee = 0;
phone->state = IPC_PHONE_HUNGUP;
spinlock_unlock(&phone->lock);
 
297,7 → 294,7
int ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox)
{
spinlock_lock(&oldbox->lock);
list_remove(&call->list);
list_remove(&call->link);
spinlock_unlock(&oldbox->lock);
 
return ipc_call(newphone, call);
330,22 → 327,22
ipl = interrupts_disable();
spinlock_lock(&box->irq_lock);
 
request = list_get_instance(box->irq_notifs.next, call_t, list);
list_remove(&request->list);
request = list_get_instance(box->irq_notifs.next, call_t, link);
list_remove(&request->link);
 
spinlock_unlock(&box->irq_lock);
interrupts_restore(ipl);
} else if (!list_empty(&box->answers)) {
/* Handle asynchronous answers */
request = list_get_instance(box->answers.next, call_t, list);
list_remove(&request->list);
request = list_get_instance(box->answers.next, call_t, link);
list_remove(&request->link);
atomic_dec(&request->data.phone->active_calls);
} else if (!list_empty(&box->calls)) {
/* Handle requests */
request = list_get_instance(box->calls.next, call_t, list);
list_remove(&request->list);
request = list_get_instance(box->calls.next, call_t, link);
list_remove(&request->link);
/* Append request to dispatch queue */
list_append(&request->list, &box->dispatched_calls);
list_append(&request->link, &box->dispatched_calls);
} else {
/* This can happen regularly after ipc_cleanup, remove
* the warning in the future when the IPC is
364,8 → 361,8
call_t *call;
 
while (!list_empty(lst)) {
call = list_get_instance(lst->next, call_t, list);
list_remove(&call->list);
call = list_get_instance(lst->next, call_t, link);
list_remove(&call->link);
 
IPC_SET_RETVAL(call->data, EHANGUP);
_ipc_answer_free_call(call);
394,8 → 391,7
spinlock_lock(&task->answerbox.lock);
while (!list_empty(&task->answerbox.connected_phones)) {
phone = list_get_instance(task->answerbox.connected_phones.next,
phone_t,
list);
phone_t, link);
if (! spinlock_trylock(&phone->lock)) {
spinlock_unlock(&task->answerbox.lock);
goto restart_phones;
404,7 → 400,7
/* Disconnect phone */
ASSERT(phone->state == IPC_PHONE_CONNECTED);
phone->state = IPC_PHONE_SLAMMED;
list_remove(&phone->list);
list_remove(&phone->link);
 
spinlock_unlock(&phone->lock);
}
451,3 → 447,82
ipc_irq_make_table(IRQ_COUNT);
}
 
 
/** Kconsole - list answerbox contents */
void ipc_print_task(task_id_t taskid)
{
task_t *task;
int i;
call_t *call;
link_t *tmp;
spinlock_lock(&tasks_lock);
task = task_find_by_id(taskid);
if (task)
spinlock_lock(&task->lock);
spinlock_unlock(&tasks_lock);
if (!task)
return;
 
/* Print opened phones & details */
printf("PHONE:\n");
for (i=0; i < IPC_MAX_PHONES;i++) {
spinlock_lock(&task->phones[i].lock);
if (task->phones[i].state != IPC_PHONE_FREE) {
printf("%d: ",i);
switch (task->phones[i].state) {
case IPC_PHONE_CONNECTING:
printf("connecting ");
break;
case IPC_PHONE_CONNECTED:
printf("connected to: %P ",
task->phones[i].callee);
break;
case IPC_PHONE_SLAMMED:
printf("slammed by: %P ",
task->phones[i].callee);
break;
case IPC_PHONE_HUNGUP:
printf("hung up - was: %P ",
task->phones[i].callee);
break;
default:
break;
}
printf("active: %d\n", atomic_get(&task->phones[i].active_calls));
}
spinlock_unlock(&task->phones[i].lock);
}
 
 
/* Print answerbox - calls */
spinlock_lock(&task->answerbox.lock);
printf("ABOX - CALLS:\n");
for (tmp=task->answerbox.calls.next; tmp != &task->answerbox.calls;tmp = tmp->next) {
call = list_get_instance(tmp, call_t, link);
printf("Callid: %P Srctask:%lld M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
call->sender->taskid, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), call->flags);
}
/* Print answerbox - calls */
printf("ABOX - DISPATCHED CALLS:\n");
for (tmp=task->answerbox.dispatched_calls.next;
tmp != &task->answerbox.dispatched_calls;
tmp = tmp->next) {
call = list_get_instance(tmp, call_t, link);
printf("Callid: %P Srctask:%lld M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
call->sender->taskid, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), call->flags);
}
/* Print answerbox - calls */
printf("ABOX - ANSWERS:\n");
for (tmp=task->answerbox.answers.next; tmp != &task->answerbox.answers; tmp = tmp->next) {
call = list_get_instance(tmp, call_t, link);
printf("Callid:%P M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), call->flags);
}
 
spinlock_unlock(&task->answerbox.lock);
spinlock_unlock(&task->lock);
}
/kernel/trunk/generic/src/ipc/irq.c
224,7 → 224,7
code_execute(call, irq_conns[irq].code);
 
spinlock_lock(&irq_conns[irq].box->irq_lock);
list_append(&call->list, &irq_conns[irq].box->irq_notifs);
list_append(&call->link, &irq_conns[irq].box->irq_notifs);
spinlock_unlock(&irq_conns[irq].box->irq_lock);
 
waitq_wakeup(&irq_conns[irq].box->wq, 0);