Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/ipc/sysipc.c

    ra53ed3a raddbce4  
    155155 * @param olddata Saved data of the request.
    156156 *
    157  * @return Return EOK on success or an error code.
    158  *
    159  */
    160 errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
    161 {
    162         errno_t rc = EOK;
     157 * @return Return EOK on success or a negative error code.
     158 *
     159 */
     160int answer_preprocess(call_t *answer, ipc_data_t *olddata)
     161{
     162        int rc = EOK;
    163163
    164164        spinlock_lock(&answer->forget_lock);
    … …  
    194194        spinlock_unlock(&answer->forget_lock);
    195195
    196         if ((errno_t) IPC_GET_RETVAL(answer->data) == EHANGUP) {
     196        if ((native_t) IPC_GET_RETVAL(answer->data) == EHANGUP) {
    197197                phone_t *phone = answer->caller_phone;
    198198                mutex_lock(&phone->lock);
    … …  
    222222 *
    223223 */
    224 static errno_t request_preprocess(call_t *call, phone_t *phone)
     224static int request_preprocess(call_t *call, phone_t *phone)
    225225{
    226226        call->request_method = IPC_GET_IMETHOD(call->data);
    … …  
    239239static void process_answer(call_t *call)
    240240{
    241         if (((errno_t) IPC_GET_RETVAL(call->data) == EHANGUP) &&
     241        if (((native_t) IPC_GET_RETVAL(call->data) == EHANGUP) &&
    242242            (call->flags & IPC_CALL_FORWARDED))
    243243                IPC_SET_RETVAL(call->data, EFORWARD);
    … …  
    271271 *
    272272 */
    273 errno_t ipc_req_internal(cap_handle_t handle, ipc_data_t *data, sysarg_t priv)
     273int ipc_req_internal(cap_handle_t handle, ipc_data_t *data, sysarg_t priv)
    274274{
    275275        kobject_t *kobj = kobject_get(TASK, handle, KOBJECT_TYPE_PHONE);
    … …  
    281281        memcpy(call->data.args, data->args, sizeof(data->args));
    282282       
    283         errno_t rc = request_preprocess(call, kobj->phone);
     283        int rc = request_preprocess(call, kobj->phone);
    284284        if (!rc) {
    285285#ifdef CONFIG_UDEBUG
    … …  
    359359 *
    360360 * @return EOK on success.
    361  * @return An error code on error.
    362  *
    363  */
    364 sys_errno_t sys_ipc_call_async_fast(sysarg_t handle, sysarg_t imethod,
     361 * @return Negative error code on error.
     362 *
     363 */
     364sysarg_t sys_ipc_call_async_fast(sysarg_t handle, sysarg_t imethod,
    365365    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t label)
    366366{
    … …  
    389389        call->data.label = label;
    390390       
    391         errno_t res = request_preprocess(call, kobj->phone);
     391        int res = request_preprocess(call, kobj->phone);
    392392       
    393393        if (!res)
    … …  
    409409 *
    410410 */
    411 sys_errno_t sys_ipc_call_async_slow(sysarg_t handle, ipc_data_t *data,
     411sysarg_t sys_ipc_call_async_slow(sysarg_t handle, ipc_data_t *data,
    412412    sysarg_t label)
    413413{
    … …  
    422422
    423423        call_t *call = ipc_call_alloc(0);
    424         errno_t rc = copy_from_uspace(&call->data.args, &data->args,
     424        int rc = copy_from_uspace(&call->data.args, &data->args,
    425425            sizeof(call->data.args));
    426         if (rc != EOK) {
     426        if (rc != 0) {
    427427                kobject_put(call->kobject);
    428428                kobject_put(kobj);
    429                 return (sys_errno_t) rc;
     429                return (sysarg_t) rc;
    430430        }
    431431
    … …  
    433433        call->data.label = label;
    434434       
    435         errno_t res = request_preprocess(call, kobj->phone);
     435        int res = request_preprocess(call, kobj->phone);
    436436       
    437437        if (!res)
    … …  
    466466 *
    467467 */
    468 static sys_errno_t sys_ipc_forward_common(sysarg_t chandle, sysarg_t phandle,
     468static sysarg_t sys_ipc_forward_common(sysarg_t chandle, sysarg_t phandle,
    469469    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
    470470    sysarg_t arg4, sysarg_t arg5, unsigned int mode, bool slow)
    … …  
    482482       
    483483        bool after_forward = false;
    484         errno_t rc;
     484        int rc;
    485485
    486486        kobject_t *pkobj = kobject_get(TASK, phandle, KOBJECT_TYPE_PHONE);
    … …  
    577577 *
    578578 */
    579 sys_errno_t sys_ipc_forward_fast(sysarg_t chandle, sysarg_t phandle,
     579sysarg_t sys_ipc_forward_fast(sysarg_t chandle, sysarg_t phandle,
    580580    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
    581581{
    … …  
    601601 *
    602602 */
    603 sys_errno_t sys_ipc_forward_slow(sysarg_t chandle, sysarg_t phandle,
     603sysarg_t sys_ipc_forward_slow(sysarg_t chandle, sysarg_t phandle,
    604604    ipc_data_t *data, unsigned int mode)
    605605{
    606606        ipc_data_t newdata;
    607         errno_t rc = copy_from_uspace(&newdata.args, &data->args,
     607        int rc = copy_from_uspace(&newdata.args, &data->args,
    608608            sizeof(newdata.args));
    609         if (rc != EOK)
    610                 return (sys_errno_t) rc;
     609        if (rc != 0)
     610                return (sysarg_t) rc;
    611611       
    612612        return sys_ipc_forward_common(chandle, phandle,
    … …  
    631631 *
    632632 */
    633 sys_errno_t sys_ipc_answer_fast(sysarg_t chandle, sysarg_t retval, sysarg_t arg1,
     633sysarg_t sys_ipc_answer_fast(sysarg_t chandle, sysarg_t retval, sysarg_t arg1,
    634634    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
    635635{
    … …  
    660660         */
    661661        IPC_SET_ARG5(call->data, 0);
    662         errno_t rc = answer_preprocess(call, saved ? &saved_data : NULL);
     662        int rc = answer_preprocess(call, saved ? &saved_data : NULL);
    663663       
    664664        ipc_answer(&TASK->answerbox, call);
    … …  
    678678 *
    679679 */
    680 sys_errno_t sys_ipc_answer_slow(sysarg_t chandle, ipc_data_t *data)
     680sysarg_t sys_ipc_answer_slow(sysarg_t chandle, ipc_data_t *data)
    681681{
    682682        kobject_t *kobj = cap_unpublish(TASK, chandle, KOBJECT_TYPE_CALL);
    … …  
    695695                saved = false;
    696696       
    697         errno_t rc = copy_from_uspace(&call->data.args, &data->args,
     697        int rc = copy_from_uspace(&call->data.args, &data->args,
    698698            sizeof(call->data.args));
    699         if (rc != EOK) {
     699        if (rc != 0) {
    700700                /*
    701701                 * Republish the capability so that the call does not get lost.
    … …  
    722722 *
    723723 */
    724 sys_errno_t sys_ipc_hangup(sysarg_t handle)
     724sysarg_t sys_ipc_hangup(sysarg_t handle)
    725725{
    726726        kobject_t *kobj = kobject_get(TASK, handle, KOBJECT_TYPE_PHONE);
    … …  
    728728                return ENOENT;
    729729       
    730         errno_t rc = ipc_phone_hangup(kobj->phone);
     730        if (ipc_phone_hangup(kobj->phone)) {
     731                kobject_put(kobj);
     732                return -1;
     733        }
     734       
    731735        kobject_put(kobj);
    732         return rc;
     736        return 0;
    733737}
    734738
    … …  
    740744 *                 for explanation.
    741745 *
    742  * @return An error code on error.
    743  */
    744 sys_errno_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
     746 * @return Capability handle of the received request.
     747 * @return CAP_NIL for answers, notifications and when there is no call.
     748 * @return Negative error code on error.
     749 */
     750sysarg_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
    745751    unsigned int flags)
    746752{
    … …  
    761767
    762768        if (!call) {
    763                 ipc_data_t data = {};
    764                 data.cap_handle = CAP_NIL;
    765                 STRUCT_TO_USPACE(calldata, &data);
    766                 return EOK;
    767         }
    768        
    769         call->data.flags = call->flags;
     769                STRUCT_TO_USPACE(calldata, &(ipc_data_t){});
     770                return CAP_NIL;
     771        }
     772       
    770773        if (call->flags & IPC_CALL_NOTIF) {
    771774                /* Set in_phone_hash to the interrupt counter */
    772775                call->data.phone = (void *) call->priv;
    773776               
    774                 call->data.cap_handle = CAP_NIL;
     777                call->data.flags = IPC_CALL_NOTIF;
    775778
    776779                STRUCT_TO_USPACE(calldata, &call->data);
    777780                kobject_put(call->kobject);
    778781               
    779                 return EOK;
     782                return CAP_NIL;
    780783        }
    781784       
    … …  
    788791                }
    789792
    790                 call->data.cap_handle = CAP_NIL;
     793                call->data.flags = IPC_CALL_ANSWERED;
    791794               
    792795                STRUCT_TO_USPACE(calldata, &call->data);
    793796                kobject_put(call->kobject);
    794797               
    795                 return EOK;
     798                return CAP_NIL;
    796799        }
    797800       
    … …  
    799802                goto restart;
    800803       
    801         cap_handle_t handle;
    802         errno_t rc = cap_alloc(TASK, &handle);
    803         if (rc != EOK) {
     804        int rc;
     805        cap_handle_t handle = cap_alloc(TASK);
     806        if (handle < 0) {
     807                rc = handle;
    804808                goto error;
    805809        }
    806810       
    807         call->data.cap_handle = handle;
    808 
    809811        /*
    810812         * Include phone hash of the caller in the request, copy the whole
    … …  
    817819        kobject_add_ref(call->kobject);
    818820        cap_publish(TASK, handle, call->kobject);
    819         return EOK;
     821        return handle;
    820822
    821823error:
    … …  
    825827        /*
    826828         * The callee will not receive this call and no one else has a chance to
    827          * answer it. Set the IPC_CALL_AUTO_REPLY flag and return the EPARTY
    828          * error code.
     829         * answer it. Reply with the EPARTY error code.
    829830         */
    830831        ipc_data_t saved_data;
    … …  
    839840        IPC_SET_RETVAL(call->data, EPARTY);
    840841        (void) answer_preprocess(call, saved ? &saved_data : NULL);
    841         call->flags |= IPC_CALL_AUTO_REPLY;
    842842        ipc_answer(&TASK->answerbox, call);
    843843
    … …  
    848848 *
    849849 */
    850 sys_errno_t sys_ipc_poke(void)
     850sysarg_t sys_ipc_poke(void)
    851851{
    852852        waitq_unsleep(&TASK->answerbox.wq);
    … …  
    860860 * @param ucode   Uspace pointer to the top-half pseudocode.
    861861 *
    862  * @param[out] uspace_handle  Uspace pointer to IRQ kernel object capability
    863  *
     862 * @return IRQ kernel object capability
    864863 * @return EPERM
    865864 * @return Error code returned by ipc_irq_subscribe().
    866865 *
    867866 */
    868 sys_errno_t sys_ipc_irq_subscribe(inr_t inr, sysarg_t imethod, irq_code_t *ucode,
    869         cap_handle_t *uspace_handle)
     867sysarg_t sys_ipc_irq_subscribe(inr_t inr, sysarg_t imethod, irq_code_t *ucode)
    870868{
    871869        if (!(perm_get(TASK) & PERM_IRQ_REG))
    872870                return EPERM;
    873871       
    874         return ipc_irq_subscribe(&TASK->answerbox, inr, imethod, ucode, uspace_handle);
     872        return ipc_irq_subscribe(&TASK->answerbox, inr, imethod, ucode);
    875873}
    876874
    … …  
    883881 *
    884882 */
    885 sys_errno_t sys_ipc_irq_unsubscribe(sysarg_t cap)
     883sysarg_t sys_ipc_irq_unsubscribe(sysarg_t cap)
    886884{
    887885        if (!(perm_get(TASK) & PERM_IRQ_REG))
    … …  
    893891}
    894892
    895 /** Syscall connect to a task by ID
    896  *
    897  * @return Error code.
    898  *
    899  */
    900 sys_errno_t sys_ipc_connect_kbox(task_id_t *uspace_taskid, cap_handle_t *uspace_phone)
     893#ifdef __32_BITS__
     894
     895/** Syscall connect to a task by ID (32 bits)
     896 *
     897 * @return Phone id on success, or negative error code.
     898 *
     899 */
     900sysarg_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid)
    901901{
    902902#ifdef CONFIG_UDEBUG
    903         task_id_t taskid;
    904         cap_handle_t phone;
    905        
    906         errno_t rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(task_id_t));
    907         if (rc == EOK) {
    908                 rc = ipc_connect_kbox((task_id_t) taskid, &phone);
    909         }
    910        
    911         if (rc == EOK) {
    912                 rc = copy_to_uspace(uspace_phone, &phone, sizeof(cap_handle_t));
    913                 if (rc != EOK) {
    914                         // Clean up the phone on failure.
    915                         sys_ipc_hangup(phone);
    916                 }
    917         }
    918        
    919         return (sys_errno_t) rc;
     903        sysarg64_t taskid;
     904        int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(sysarg64_t));
     905        if (rc != 0)
     906                return (sysarg_t) rc;
     907       
     908        return ipc_connect_kbox((task_id_t) taskid);
    920909#else
    921         return (sys_errno_t) ENOTSUP;
     910        return (sysarg_t) ENOTSUP;
    922911#endif
    923912}
    924913
     914#endif  /* __32_BITS__ */
     915
     916#ifdef __64_BITS__
     917
     918/** Syscall connect to a task by ID (64 bits)
     919 *
     920 * @return Phone id on success, or negative error code.
     921 *
     922 */
     923sysarg_t sys_ipc_connect_kbox(sysarg_t taskid)
     924{
     925#ifdef CONFIG_UDEBUG
     926        return ipc_connect_kbox((task_id_t) taskid);
     927#else
     928        return (sysarg_t) ENOTSUP;
     929#endif
     930}
     931
     932#endif  /* __64_BITS__ */
     933
    925934/** @}
    926935 */
Note: See TracChangeset for help on using the changeset viewer.