Changeset a46e56b in mainline for uspace/srv/devman/drv_conn.c


Ignore:
Timestamp:
2018-03-22T06:49:35Z (7 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
77f0a1d
Parents:
3e242d2
git-author:
Jakub Jermar <jakub@…> (2018-03-21 23:29:06)
git-committer:
Jakub Jermar <jakub@…> (2018-03-22 06:49:35)
Message:

Prefer handle over ID in naming handle variables

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devman/drv_conn.c

    r3e242d2 ra46e56b  
    6464
    6565/** Register running driver. */
    66 static driver_t *devman_driver_register(cap_call_handle_t callid, ipc_call_t *call)
     66static driver_t *devman_driver_register(cap_call_handle_t chandle, ipc_call_t *call)
    6767{
    6868        driver_t *driver = NULL;
    … …  
    7474        errno_t rc = async_data_write_accept((void **) &drv_name, true, 0, 0, 0, 0);
    7575        if (rc != EOK) {
    76                 async_answer_0(callid, rc);
     76                async_answer_0(chandle, rc);
    7777                return NULL;
    7878        }
    … …  
    8787                free(drv_name);
    8888                drv_name = NULL;
    89                 async_answer_0(callid, ENOENT);
     89                async_answer_0(chandle, ENOENT);
    9090                return NULL;
    9191        }
    … …  
    101101                    driver->name);
    102102                fibril_mutex_unlock(&driver->driver_mutex);
    103                 async_answer_0(callid, EEXIST);
     103                async_answer_0(chandle, EEXIST);
    104104                return NULL;
    105105        }
    … …  
    126126        if (!driver->sess) {
    127127                fibril_mutex_unlock(&driver->driver_mutex);
    128                 async_answer_0(callid, ENOTSUP);
     128                async_answer_0(chandle, ENOTSUP);
    129129                return NULL;
    130130        }
    … …  
    146146                    "for driver `%s'.", driver->name);
    147147                fibril_mutex_unlock(&driver->driver_mutex);
    148                 async_answer_0(callid, ENOMEM);
     148                async_answer_0(chandle, ENOMEM);
    149149                return NULL;
    150150        }
    … …  
    153153        fibril_mutex_unlock(&driver->driver_mutex);
    154154
    155         async_answer_0(callid, EOK);
     155        async_answer_0(chandle, EOK);
    156156        return driver;
    157157}
    … …  
    166166{
    167167        match_id_t *match_id = create_match_id();
    168         cap_call_handle_t callid;
     168        cap_call_handle_t chandle;
    169169        ipc_call_t call;
    170170        errno_t rc = 0;
    171171
    172         callid = async_get_call(&call);
     172        chandle = async_get_call(&call);
    173173        if (DEVMAN_ADD_MATCH_ID != IPC_GET_IMETHOD(call)) {
    174174                log_msg(LOG_DEFAULT, LVL_ERROR,
    175175                    "Invalid protocol when trying to receive match id.");
    176                 async_answer_0(callid, EINVAL);
     176                async_answer_0(chandle, EINVAL);
    177177                delete_match_id(match_id);
    178178                return EINVAL;
    … …  
    181181        if (match_id == NULL) {
    182182                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to allocate match id.");
    183                 async_answer_0(callid, ENOMEM);
     183                async_answer_0(chandle, ENOMEM);
    184184                return ENOMEM;
    185185        }
    186186
    187         async_answer_0(callid, EOK);
     187        async_answer_0(chandle, EOK);
    188188
    189189        match_id->score = IPC_GET_ARG1(call);
    … …  
    230230 * Child devices are registered by their parent's device driver.
    231231 */
    232 static void devman_add_function(cap_call_handle_t callid, ipc_call_t *call)
     232static void devman_add_function(cap_call_handle_t chandle, ipc_call_t *call)
    233233{
    234234        fun_type_t ftype = (fun_type_t) IPC_GET_ARG1(*call);
    … …  
    239239        dev_node_t *pdev = find_dev_node(&device_tree, dev_handle);
    240240        if (pdev == NULL) {
    241                 async_answer_0(callid, ENOENT);
     241                async_answer_0(chandle, ENOENT);
    242242                return;
    243243        }
    … …  
    250250
    251251                dev_del_ref(pdev);
    252                 async_answer_0(callid, EINVAL);
     252                async_answer_0(chandle, EINVAL);
    253253                return;
    254254        }
    … …  
    258258        if (rc != EOK) {
    259259                dev_del_ref(pdev);
    260                 async_answer_0(callid, rc);
     260                async_answer_0(chandle, rc);
    261261                return;
    262262        }
    … …  
    268268                fibril_rwlock_write_unlock(&tree->rwlock);
    269269                dev_del_ref(pdev);
    270                 async_answer_0(callid, ENOENT);
     270                async_answer_0(chandle, ENOENT);
    271271                return;
    272272        }
    … …  
    278278                fibril_rwlock_write_unlock(&tree->rwlock);
    279279                dev_del_ref(pdev);
    280                 async_answer_0(callid, EEXIST);
     280                async_answer_0(chandle, EEXIST);
    281281                printf(NAME ": Warning, driver tried to register `%s' twice.\n",
    282282                    fun_name);
    … …  
    303303                fun_del_ref(fun);
    304304                delete_fun_node(fun);
    305                 async_answer_0(callid, ENOMEM);
     305                async_answer_0(chandle, ENOMEM);
    306306                return;
    307307        }
    … …  
    317317                fun_busy_unlock(fun);
    318318                fun_del_ref(fun);
    319                 async_answer_0(callid, rc);
     319                async_answer_0(chandle, rc);
    320320                return;
    321321        }
    … …  
    325325
    326326        /* Return device handle to parent's driver. */
    327         async_answer_1(callid, EOK, fun->handle);
    328 }
    329 
    330 static void devman_add_function_to_cat(cap_call_handle_t callid, ipc_call_t *call)
     327        async_answer_1(chandle, EOK, fun->handle);
     328}
     329
     330static void devman_add_function_to_cat(cap_call_handle_t chandle, ipc_call_t *call)
    331331{
    332332        devman_handle_t handle = IPC_GET_ARG1(*call);
    … …  
    339339            0, 0, 0, 0);
    340340        if (rc != EOK) {
    341                 async_answer_0(callid, rc);
     341                async_answer_0(chandle, rc);
    342342                return;
    343343        }
    … …  
    345345        fun_node_t *fun = find_fun_node(&device_tree, handle);
    346346        if (fun == NULL) {
    347                 async_answer_0(callid, ENOENT);
     347                async_answer_0(chandle, ENOENT);
    348348                return;
    349349        }
    … …  
    354354        if (fun->state == FUN_REMOVED) {
    355355                fibril_rwlock_read_unlock(&device_tree.rwlock);
    356                 async_answer_0(callid, ENOENT);
     356                async_answer_0(chandle, ENOENT);
    357357                return;
    358358        }
    … …  
    371371        fun_del_ref(fun);
    372372
    373         async_answer_0(callid, rc);
     373        async_answer_0(chandle, rc);
    374374}
    375375
    … …  
    377377 *
    378378 */
    379 static void devman_drv_fun_online(cap_call_handle_t iid, ipc_call_t *icall,
     379static void devman_drv_fun_online(cap_call_handle_t icall_handle, ipc_call_t *icall,
    380380    driver_t *drv)
    381381{
    … …  
    387387        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
    388388        if (fun == NULL) {
    389                 async_answer_0(iid, ENOENT);
     389                async_answer_0(icall_handle, ENOENT);
    390390                return;
    391391        }
    … …  
    398398                fun_busy_unlock(fun);
    399399                fun_del_ref(fun);
    400                 async_answer_0(iid, ENOENT);
     400                async_answer_0(icall_handle, ENOENT);
    401401                return;
    402402        }
    … …  
    407407                fun_busy_unlock(fun);
    408408                fun_del_ref(fun);
    409                 async_answer_0(iid, rc);
     409                async_answer_0(icall_handle, rc);
    410410                return;
    411411        }
    … …  
    414414        fun_del_ref(fun);
    415415
    416         async_answer_0(iid, EOK);
     416        async_answer_0(icall_handle, EOK);
    417417}
    418418
    … …  
    421421 *
    422422 */
    423 static void devman_drv_fun_offline(cap_call_handle_t iid, ipc_call_t *icall,
     423static void devman_drv_fun_offline(cap_call_handle_t icall_handle, ipc_call_t *icall,
    424424    driver_t *drv)
    425425{
    … …  
    429429        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
    430430        if (fun == NULL) {
    431                 async_answer_0(iid, ENOENT);
     431                async_answer_0(icall_handle, ENOENT);
    432432                return;
    433433        }
    … …  
    439439                fun_busy_unlock(fun);
    440440                fun_del_ref(fun);
    441                 async_answer_0(iid, ENOENT);
     441                async_answer_0(icall_handle, ENOENT);
    442442                return;
    443443        }
    … …  
    448448                fun_busy_unlock(fun);
    449449                fun_del_ref(fun);
    450                 async_answer_0(iid, rc);
     450                async_answer_0(icall_handle, rc);
    451451                return;
    452452        }
    … …  
    454454        fun_busy_unlock(fun);
    455455        fun_del_ref(fun);
    456         async_answer_0(iid, EOK);
     456        async_answer_0(icall_handle, EOK);
    457457}
    458458
    459459/** Remove function. */
    460 static void devman_remove_function(cap_call_handle_t callid, ipc_call_t *call)
     460static void devman_remove_function(cap_call_handle_t chandle, ipc_call_t *call)
    461461{
    462462        devman_handle_t fun_handle = IPC_GET_ARG1(*call);
    … …  
    466466        fun_node_t *fun = find_fun_node(&device_tree, fun_handle);
    467467        if (fun == NULL) {
    468                 async_answer_0(callid, ENOENT);
     468                async_answer_0(chandle, ENOENT);
    469469                return;
    470470        }
    … …  
    481481                fun_busy_unlock(fun);
    482482                fun_del_ref(fun);
    483                 async_answer_0(callid, ENOENT);
     483                async_answer_0(chandle, ENOENT);
    484484                return;
    485485        }
    … …  
    523523                                fun_busy_unlock(fun);
    524524                                fun_del_ref(fun);
    525                                 async_answer_0(callid, gone_rc);
     525                                async_answer_0(chandle, gone_rc);
    526526                                return;
    527527                        }
    … …  
    551551                                fun_busy_unlock(fun);
    552552                                fun_del_ref(fun);
    553                                 async_answer_0(callid, EIO);
     553                                async_answer_0(chandle, EIO);
    554554                                return;
    555555                        }
    … …  
    567567
    568568        log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_remove_function() succeeded.");
    569         async_answer_0(callid, EOK);
     569        async_answer_0(chandle, EOK);
    570570}
    571571
    … …  
    586586
    587587/** Function for handling connections from a driver to the device manager. */
    588 void devman_connection_driver(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     588void devman_connection_driver(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    589589{
    590590        client_t *client;
    … …  
    592592
    593593        /* Accept the connection. */
    594         async_answer_0(iid, EOK);
     594        async_answer_0(icall_handle, EOK);
    595595
    596596        client = async_get_client_data();
    … …  
    602602        while (true) {
    603603                ipc_call_t call;
    604                 cap_call_handle_t callid = async_get_call(&call);
     604                cap_call_handle_t chandle = async_get_call(&call);
    605605
    606606                if (!IPC_GET_IMETHOD(call))
    … …  
    613613                        if (driver == NULL) {
    614614                                /* First call must be to DEVMAN_DRIVER_REGISTER */
    615                                 async_answer_0(callid, ENOTSUP);
     615                                async_answer_0(chandle, ENOTSUP);
    616616                                continue;
    617617                        }
    … …  
    623623                        if (client->driver != NULL) {
    624624                                fibril_mutex_unlock(&client->mutex);
    625                                 async_answer_0(callid, EINVAL);
     625                                async_answer_0(chandle, EINVAL);
    626626                                continue;
    627627                        }
    628                         client->driver = devman_driver_register(callid, &call);
     628                        client->driver = devman_driver_register(chandle, &call);
    629629                        fibril_mutex_unlock(&client->mutex);
    630630                        break;
    631631                case DEVMAN_ADD_FUNCTION:
    632                         devman_add_function(callid, &call);
     632                        devman_add_function(chandle, &call);
    633633                        break;
    634634                case DEVMAN_ADD_DEVICE_TO_CATEGORY:
    635                         devman_add_function_to_cat(callid, &call);
     635                        devman_add_function_to_cat(chandle, &call);
    636636                        break;
    637637                case DEVMAN_DRV_FUN_ONLINE:
    638                         devman_drv_fun_online(callid, &call, driver);
     638                        devman_drv_fun_online(chandle, &call, driver);
    639639                        break;
    640640                case DEVMAN_DRV_FUN_OFFLINE:
    641                         devman_drv_fun_offline(callid, &call, driver);
     641                        devman_drv_fun_offline(chandle, &call, driver);
    642642                        break;
    643643                case DEVMAN_REMOVE_FUNCTION:
    644                         devman_remove_function(callid, &call);
     644                        devman_remove_function(chandle, &call);
    645645                        break;
    646646                default:
    647                         async_answer_0(callid, EINVAL);
     647                        async_answer_0(chandle, EINVAL);
    648648                        break;
    649649                }
Note: See TracChangeset for help on using the changeset viewer.