Changeset c4e4507 in mainline


Ignore:
Timestamp:
2006-06-04T17:17:29Z (19 years ago)
Author:
Ondrej Palkovsky <ondrap@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
2cb5e64
Parents:
fe19611
Message:

Renamed some things in IPC to be consistent.
Added ipc reporting to kconsole.

Location:
generic
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • generic/include/ipc/ipc.h

    rfe19611 rc4e4507  
    186186} ipc_phone_state_t;
    187187
     188/** Structure identifying phone (in TASK structure) */
    188189struct phone_s {
    189190        SPINLOCK_DECLARE(lock);
    190         link_t list;
     191        link_t link;
    191192        answerbox_t *callee;
    192193        ipc_phone_state_t state;
    … …  
    195196
    196197typedef struct {
    197         link_t list;
     198        link_t link;
    198199
    199200        int flags;
    … …  
    227228extern int ipc_phone_hangup(phone_t *phone, int aggressive);
    228229extern void ipc_backsend_err(phone_t *phone, call_t *call, __native err);
     230extern void ipc_print_task(task_id_t taskid);
    229231
    230232extern answerbox_t *ipc_phone_0;

  • generic/src/console/cmd.c

    rfe19611 rc4e4507  
    5959#include <proc/thread.h>
    6060#include <proc/task.h>
     61#include <ipc/ipc.h>
    6162
    6263/** Data and methods for 'help' command. */
    … …  
    301302};
    302303
     304/** Data and methods for 'ipc_task' command */
     305static int cmd_ipc_task(cmd_arg_t *argv);
     306static cmd_arg_t ipc_task_argv = {
     307        .type = ARG_TYPE_INT,
     308};
     309static cmd_info_t ipc_task_info = {
     310        .name = "ipc_task",
     311        .description = "Show memory zone structure.",
     312        .func = cmd_ipc_task,
     313        .argc = 1,
     314        .argv = &ipc_task_argv
     315};
     316
    303317/** Data and methods for 'zone' command */
    304318static int cmd_zone(cmd_arg_t *argv);
    … …  
    348362        &halt_info,
    349363        &help_info,
     364        &ipc_task_info,
    350365        &set4_info,
    351366        &slabs_info,
    … …  
    687702}
    688703
     704/** Command for printing task ipc details
     705 *
     706 * @param argv Integer argument from cmdline expected
     707 *
     708 * return Always 1
     709 */
     710int cmd_ipc_task(cmd_arg_t * argv) {
     711        ipc_print_task(argv[0].intval);
     712        return 1;
     713}
     714
     715
    689716/** Command for listing processors.
    690717 *

  • generic/src/ipc/ipc.c

    rfe19611 rc4e4507  
    111111        spinlock_lock(&phone->lock);
    112112
    113         ASSERT(!phone->callee);
    114113        phone->state = IPC_PHONE_CONNECTED;
    115114        phone->callee = box;
    116115
    117116        spinlock_lock(&box->lock);
    118         list_append(&phone->list, &box->connected_phones);
     117        list_append(&phone->link, &box->connected_phones);
    119118        spinlock_unlock(&box->lock);
    120119
    … …  
    156155
    157156        spinlock_lock(&callerbox->lock);
    158         list_append(&call->list, &callerbox->answers);
     157        list_append(&call->link, &callerbox->answers);
    159158        spinlock_unlock(&callerbox->lock);
    160159        waitq_wakeup(&callerbox->wq, 0);
    … …  
    170169        /* Remove from active box */
    171170        spinlock_lock(&box->lock);
    172         list_remove(&call->list);
     171        list_remove(&call->link);
    173172        spinlock_unlock(&box->lock);
    174173        /* Send back answer */
    … …  
    198197
    199198        spinlock_lock(&box->lock);
    200         list_append(&call->list, &box->calls);
     199        list_append(&call->link, &box->calls);
    201200        spinlock_unlock(&box->lock);
    202201        waitq_wakeup(&box->wq, 0);
    … …  
    262261                /* Remove myself from answerbox */
    263262                spinlock_lock(&box->lock);
    264                 list_remove(&phone->list);
     263                list_remove(&phone->link);
    265264                spinlock_unlock(&box->lock);
    266265
    … …  
    277276        }
    278277
    279         phone->callee = 0;
    280        
    281278        phone->state = IPC_PHONE_HUNGUP;
    282279        spinlock_unlock(&phone->lock);
    … …  
    298295{
    299296        spinlock_lock(&oldbox->lock);
    300         list_remove(&call->list);
     297        list_remove(&call->link);
    301298        spinlock_unlock(&oldbox->lock);
    302299
    … …  
    331328                spinlock_lock(&box->irq_lock);
    332329
    333                 request = list_get_instance(box->irq_notifs.next, call_t, list);
    334                 list_remove(&request->list);
     330                request = list_get_instance(box->irq_notifs.next, call_t, link);
     331                list_remove(&request->link);
    335332
    336333                spinlock_unlock(&box->irq_lock);
    … …  
    338335        } else if (!list_empty(&box->answers)) {
    339336                /* Handle asynchronous answers */
    340                 request = list_get_instance(box->answers.next, call_t, list);
    341                 list_remove(&request->list);
     337                request = list_get_instance(box->answers.next, call_t, link);
     338                list_remove(&request->link);
    342339                atomic_dec(&request->data.phone->active_calls);
    343340        } else if (!list_empty(&box->calls)) {
    344341                /* Handle requests */
    345                 request = list_get_instance(box->calls.next, call_t, list);
    346                 list_remove(&request->list);
     342                request = list_get_instance(box->calls.next, call_t, link);
     343                list_remove(&request->link);
    347344                /* Append request to dispatch queue */
    348                 list_append(&request->list, &box->dispatched_calls);
     345                list_append(&request->link, &box->dispatched_calls);
    349346        } else {
    350347                /* This can happen regularly after ipc_cleanup, remove
    … …  
    365362
    366363        while (!list_empty(lst)) {
    367                 call = list_get_instance(lst->next, call_t, list);
    368                 list_remove(&call->list);
     364                call = list_get_instance(lst->next, call_t, link);
     365                list_remove(&call->link);
    369366
    370367                IPC_SET_RETVAL(call->data, EHANGUP);
    … …  
    395392        while (!list_empty(&task->answerbox.connected_phones)) {
    396393                phone = list_get_instance(task->answerbox.connected_phones.next,
    397                                           phone_t,
    398                                           list);
     394                                          phone_t, link);
    399395                if (! spinlock_trylock(&phone->lock)) {
    400396                        spinlock_unlock(&task->answerbox.lock);
    … …  
    405401                ASSERT(phone->state == IPC_PHONE_CONNECTED);
    406402                phone->state = IPC_PHONE_SLAMMED;
    407                 list_remove(&phone->list);
     403                list_remove(&phone->link);
    408404
    409405                spinlock_unlock(&phone->lock);
    … …  
    452448}
    453449
     450
     451/** Kconsole - list answerbox contents */
     452void ipc_print_task(task_id_t taskid)
     453{
     454        task_t *task;
     455        int i;
     456        call_t *call;
     457        link_t *tmp;
     458       
     459        spinlock_lock(&tasks_lock);
     460        task = task_find_by_id(taskid);
     461        if (task)
     462                spinlock_lock(&task->lock);
     463        spinlock_unlock(&tasks_lock);
     464        if (!task)
     465                return;
     466
     467        /* Print opened phones & details */
     468        printf("PHONE:\n");
     469        for (i=0; i < IPC_MAX_PHONES;i++) {
     470                spinlock_lock(&task->phones[i].lock);
     471                if (task->phones[i].state != IPC_PHONE_FREE) {
     472                        printf("%d: ",i);
     473                        switch (task->phones[i].state) {
     474                        case IPC_PHONE_CONNECTING:
     475                                printf("connecting ");
     476                                break;
     477                        case IPC_PHONE_CONNECTED:
     478                                printf("connected to: %P ",
     479                                       task->phones[i].callee);
     480                                break;
     481                        case IPC_PHONE_SLAMMED:
     482                                printf("slammed by: %P ",
     483                                       task->phones[i].callee);
     484                                break;
     485                        case IPC_PHONE_HUNGUP:
     486                                printf("hung up - was: %P ",
     487                                       task->phones[i].callee);
     488                                break;
     489                        default:
     490                                break;
     491                        }
     492                        printf("active: %d\n", atomic_get(&task->phones[i].active_calls));
     493                }
     494                spinlock_unlock(&task->phones[i].lock);
     495        }
     496
     497
     498        /* Print answerbox - calls */
     499        spinlock_lock(&task->answerbox.lock);
     500        printf("ABOX - CALLS:\n");
     501        for (tmp=task->answerbox.calls.next; tmp != &task->answerbox.calls;tmp = tmp->next) {
     502                call = list_get_instance(tmp, call_t, link);
     503                printf("Callid: %P Srctask:%lld M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
     504                       call->sender->taskid, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
     505                       IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), call->flags);
     506        }
     507        /* Print answerbox - calls */
     508        printf("ABOX - DISPATCHED CALLS:\n");
     509        for (tmp=task->answerbox.dispatched_calls.next;
     510             tmp != &task->answerbox.dispatched_calls;
     511             tmp = tmp->next) {
     512                call = list_get_instance(tmp, call_t, link);
     513                printf("Callid: %P Srctask:%lld M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
     514                       call->sender->taskid, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
     515                       IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), call->flags);
     516        }
     517        /* Print answerbox - calls */
     518        printf("ABOX - ANSWERS:\n");
     519        for (tmp=task->answerbox.answers.next; tmp != &task->answerbox.answers; tmp = tmp->next) {
     520                call = list_get_instance(tmp, call_t, link);
     521                printf("Callid:%P M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
     522                       IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
     523                       IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), call->flags);
     524        }
     525
     526        spinlock_unlock(&task->answerbox.lock);
     527        spinlock_unlock(&task->lock);
     528}

  • generic/src/ipc/ipcrsc.c

    rfe19611 rc4e4507  
    141141        for (lst = TASK->answerbox.dispatched_calls.next;
    142142             lst != &TASK->answerbox.dispatched_calls; lst = lst->next) {
    143                 call = list_get_instance(lst, call_t, list);
     143                call = list_get_instance(lst, call_t, link);
    144144                if ((__native)call == callid) {
    145145                        result = call;
    … …  
    178178{
    179179        ASSERT(phone->state == IPC_PHONE_CONNECTING);
    180         ASSERT(! phone->callee);
    181180       
    182181        /* atomic operation */

  • generic/src/ipc/irq.c

    rfe19611 rc4e4507  
    225225
    226226                spinlock_lock(&irq_conns[irq].box->irq_lock);
    227                 list_append(&call->list, &irq_conns[irq].box->irq_notifs);
     227                list_append(&call->link, &irq_conns[irq].box->irq_notifs);
    228228                spinlock_unlock(&irq_conns[irq].box->irq_lock);
    229229

  • generic/src/ipc/sysipc.c

    rfe19611 rc4e4507  
    107107                spinlock_lock(&TASK->answerbox.lock);
    108108                if (answer->data.phone->state == IPC_PHONE_CONNECTED) {
    109                         list_remove(&answer->data.phone->list);
     109                        list_remove(&answer->data.phone->link);
    110110                        answer->data.phone->state = IPC_PHONE_SLAMMED;
    111111                }

  • generic/src/proc/task.c

    rfe19611 rc4e4507  
    230230               
    231231                        spinlock_lock(&t->lock);
    232                         printf("%s: address=%#zX, taskid=%#llX, as=%#zX, ActiveCalls: %zd",
    233                                 t->name, t, t->taskid, t->as, atomic_get(&t->active_calls));
     232                        printf("%s(%lld): address=%#zX, as=%#zX, ActiveCalls: %zd",
     233                                t->name, t->taskid, t, t->as, atomic_get(&t->active_calls));
    234234                        for (j=0; j < IPC_MAX_PHONES; j++) {
    235235                                if (t->phones[j].callee)
Note: See TracChangeset for help on using the changeset viewer.