Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/src/ipc/sysipc.c

    rfdd4898 rcc574511  
    4040#include <debug.h>
    4141#include <ipc/ipc.h>
    42 #include <abi/ipc/methods.h>
     42#include <ipc/ipc_methods.h>
    4343#include <ipc/sysipc.h>
    4444#include <ipc/irq.h>
    4545#include <ipc/ipcrsc.h>
    46 #include <ipc/event.h>
    4746#include <ipc/kbox.h>
    4847#include <synch/waitq.h>
     
    135134        case IPC_M_DATA_WRITE:
    136135        case IPC_M_DATA_READ:
    137         case IPC_M_STATE_CHANGE_AUTHORIZE:
    138136                return true;
    139137        default:
     
    166164        case IPC_M_DATA_WRITE:
    167165        case IPC_M_DATA_READ:
    168         case IPC_M_STATE_CHANGE_AUTHORIZE:
    169166                return true;
    170167        default:
     
    337334                free(answer->buffer);
    338335                answer->buffer = NULL;
    339         } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_STATE_CHANGE_AUTHORIZE) {
    340                 if (!IPC_GET_RETVAL(answer->data)) {
    341                         /* The recipient authorized the change of state. */
    342                         phone_t *recipient_phone;
    343                         task_t *other_task_s;
    344                         task_t *other_task_r;
    345                         int rc;
    346 
    347                         rc = phone_get(IPC_GET_ARG1(answer->data),
    348                             &recipient_phone);
    349                         if (rc != EOK) {
    350                                 IPC_SET_RETVAL(answer->data, ENOENT);
    351                                 return ENOENT;
    352                         }
    353 
    354                         mutex_lock(&recipient_phone->lock);
    355                         if (recipient_phone->state != IPC_PHONE_CONNECTED) {
    356                                 mutex_unlock(&recipient_phone->lock);
    357                                 IPC_SET_RETVAL(answer->data, EINVAL);
    358                                 return EINVAL;
    359                         }
    360 
    361                         other_task_r = recipient_phone->callee->task;
    362                         other_task_s = (task_t *) IPC_GET_ARG5(*olddata);
    363 
    364                         /*
    365                          * See if both the sender and the recipient meant the
    366                          * same third party task.
    367                          */
    368                         if (other_task_r != other_task_s) {
    369                                 IPC_SET_RETVAL(answer->data, EINVAL);
    370                                 rc = EINVAL;
    371                         } else {
    372                                 rc = event_task_notify_5(other_task_r,
    373                                     EVENT_TASK_STATE_CHANGE, false,
    374                                     IPC_GET_ARG1(*olddata),
    375                                     IPC_GET_ARG2(*olddata),
    376                                     IPC_GET_ARG3(*olddata),
    377                                     (sysarg_t) olddata->task,
    378                                     (sysarg_t) TASK);
    379                                 IPC_SET_RETVAL(answer->data, rc);
    380                         }
    381 
    382                         mutex_unlock(&recipient_phone->lock);
    383                         return rc;
    384                 }
    385336        }
    386337       
     
    505456                }
    506457               
    507                 break;
    508         }
    509         case IPC_M_STATE_CHANGE_AUTHORIZE: {
    510                 phone_t *sender_phone;
    511                 task_t *other_task_s;
    512 
    513                 if (phone_get(IPC_GET_ARG5(call->data), &sender_phone) != EOK)
    514                         return ENOENT;
    515 
    516                 mutex_lock(&sender_phone->lock);
    517                 if (sender_phone->state != IPC_PHONE_CONNECTED) {
    518                         mutex_unlock(&sender_phone->lock);
    519                         return EINVAL;
    520                 }
    521 
    522                 other_task_s = sender_phone->callee->task;
    523 
    524                 mutex_unlock(&sender_phone->lock);
    525 
    526                 /* Remember the third party task hash. */
    527                 IPC_SET_ARG5(call->data, (sysarg_t) other_task_s);
    528458                break;
    529459        }
Note: See TracChangeset for help on using the changeset viewer.