Changeset a46e56b in mainline for uspace/srv/bd/vbd/vbd.c


Ignore:
Timestamp:
2018-03-22T06:49:35Z (6 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/bd/vbd/vbd.c

    r3e242d2 ra46e56b  
    8787}
    8888
    89 static void vbds_get_disks_srv(cap_call_handle_t iid, ipc_call_t *icall)
    90 {
    91         cap_call_handle_t callid;
     89static void vbds_get_disks_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
     90{
     91        cap_call_handle_t chandle;
    9292        size_t size;
    9393        size_t act_size;
    9494        errno_t rc;
    9595
    96         if (!async_data_read_receive(&callid, &size)) {
    97                 async_answer_0(callid, EREFUSED);
    98                 async_answer_0(iid, EREFUSED);
     96        if (!async_data_read_receive(&chandle, &size)) {
     97                async_answer_0(chandle, EREFUSED);
     98                async_answer_0(icall_handle, EREFUSED);
    9999                return;
    100100        }
    … …  
    102102        service_id_t *id_buf = (service_id_t *) malloc(size);
    103103        if (id_buf == NULL) {
    104                 async_answer_0(callid, ENOMEM);
    105                 async_answer_0(iid, ENOMEM);
     104                async_answer_0(chandle, ENOMEM);
     105                async_answer_0(icall_handle, ENOMEM);
    106106                return;
    107107        }
    … …  
    110110        if (rc != EOK) {
    111111                free(id_buf);
    112                 async_answer_0(callid, rc);
    113                 async_answer_0(iid, rc);
    114                 return;
    115         }
    116 
    117         errno_t retval = async_data_read_finalize(callid, id_buf, size);
     112                async_answer_0(chandle, rc);
     113                async_answer_0(icall_handle, rc);
     114                return;
     115        }
     116
     117        errno_t retval = async_data_read_finalize(chandle, id_buf, size);
    118118        free(id_buf);
    119119
    120         async_answer_1(iid, retval, act_size);
    121 }
    122 
    123 static void vbds_disk_info_srv(cap_call_handle_t iid, ipc_call_t *icall)
     120        async_answer_1(icall_handle, retval, act_size);
     121}
     122
     123static void vbds_disk_info_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
    124124{
    125125        service_id_t disk_sid;
    … …  
    132132        rc = vbds_disk_info(disk_sid, &dinfo);
    133133        if (rc != EOK) {
    134                 async_answer_0(iid, rc);
    135                 return;
    136         }
    137 
    138         cap_call_handle_t callid;
    139         size_t size;
    140         if (!async_data_read_receive(&callid, &size)) {
    141                 async_answer_0(callid, EREFUSED);
    142                 async_answer_0(iid, EREFUSED);
     134                async_answer_0(icall_handle, rc);
     135                return;
     136        }
     137
     138        cap_call_handle_t chandle;
     139        size_t size;
     140        if (!async_data_read_receive(&chandle, &size)) {
     141                async_answer_0(chandle, EREFUSED);
     142                async_answer_0(icall_handle, EREFUSED);
    143143                return;
    144144        }
    145145
    146146        if (size != sizeof(vbd_disk_info_t)) {
    147                 async_answer_0(callid, EINVAL);
    148                 async_answer_0(iid, EINVAL);
    149                 return;
    150         }
    151 
    152         rc = async_data_read_finalize(callid, &dinfo,
     147                async_answer_0(chandle, EINVAL);
     148                async_answer_0(icall_handle, EINVAL);
     149                return;
     150        }
     151
     152        rc = async_data_read_finalize(chandle, &dinfo,
    153153            min(size, sizeof(dinfo)));
    154154        if (rc != EOK) {
    155                 async_answer_0(callid, rc);
    156                 async_answer_0(iid, rc);
    157                 return;
    158         }
    159 
    160         async_answer_0(iid, EOK);
    161 }
    162 
    163 static void vbds_label_create_srv(cap_call_handle_t iid, ipc_call_t *icall)
     155                async_answer_0(chandle, rc);
     156                async_answer_0(icall_handle, rc);
     157                return;
     158        }
     159
     160        async_answer_0(icall_handle, EOK);
     161}
     162
     163static void vbds_label_create_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
    164164{
    165165        service_id_t disk_sid;
    … …  
    172172        ltype = IPC_GET_ARG2(*icall);
    173173        rc = vbds_label_create(disk_sid, ltype);
    174         async_answer_0(iid, rc);
    175 }
    176 
    177 static void vbds_label_delete_srv(cap_call_handle_t iid, ipc_call_t *icall)
     174        async_answer_0(icall_handle, rc);
     175}
     176
     177static void vbds_label_delete_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
    178178{
    179179        service_id_t disk_sid;
    … …  
    184184        disk_sid = IPC_GET_ARG1(*icall);
    185185        rc = vbds_label_delete(disk_sid);
    186         async_answer_0(iid, rc);
    187 }
    188 
    189 static void vbds_label_get_parts_srv(cap_call_handle_t iid, ipc_call_t *icall)
    190 {
    191         cap_call_handle_t callid;
     186        async_answer_0(icall_handle, rc);
     187}
     188
     189static void vbds_label_get_parts_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
     190{
     191        cap_call_handle_t chandle;
    192192        size_t size;
    193193        size_t act_size;
    … …  
    197197        log_msg(LOG_DEFAULT, LVL_DEBUG, "vbds_label_get_parts_srv()");
    198198
    199         if (!async_data_read_receive(&callid, &size)) {
    200                 async_answer_0(callid, EREFUSED);
    201                 async_answer_0(iid, EREFUSED);
     199        if (!async_data_read_receive(&chandle, &size)) {
     200                async_answer_0(chandle, EREFUSED);
     201                async_answer_0(icall_handle, EREFUSED);
    202202                return;
    203203        }
    … …  
    207207        category_id_t *id_buf = (category_id_t *) malloc(size);
    208208        if (id_buf == NULL) {
    209                 async_answer_0(callid, ENOMEM);
    210                 async_answer_0(iid, ENOMEM);
     209                async_answer_0(chandle, ENOMEM);
     210                async_answer_0(icall_handle, ENOMEM);
    211211                return;
    212212        }
    … …  
    214214        rc = vbds_get_parts(sid, id_buf, size, &act_size);
    215215        if (rc != EOK) {
    216                 async_answer_0(callid, rc);
    217                 async_answer_0(iid, rc);
    218                 return;
    219         }
    220 
    221         errno_t retval = async_data_read_finalize(callid, id_buf, size);
     216                async_answer_0(chandle, rc);
     217                async_answer_0(icall_handle, rc);
     218                return;
     219        }
     220
     221        errno_t retval = async_data_read_finalize(chandle, id_buf, size);
    222222        free(id_buf);
    223223
    224         async_answer_1(iid, retval, act_size);
    225 }
    226 
    227 static void vbds_part_get_info_srv(cap_call_handle_t iid, ipc_call_t *icall)
     224        async_answer_1(icall_handle, retval, act_size);
     225}
     226
     227static void vbds_part_get_info_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
    228228{
    229229        vbds_part_id_t part;
    … …  
    236236        rc = vbds_part_get_info(part, &pinfo);
    237237        if (rc != EOK) {
    238                 async_answer_0(iid, rc);
    239                 return;
    240         }
    241 
    242         cap_call_handle_t callid;
    243         size_t size;
    244         if (!async_data_read_receive(&callid, &size)) {
    245                 async_answer_0(callid, EREFUSED);
    246                 async_answer_0(iid, EREFUSED);
     238                async_answer_0(icall_handle, rc);
     239                return;
     240        }
     241
     242        cap_call_handle_t chandle;
     243        size_t size;
     244        if (!async_data_read_receive(&chandle, &size)) {
     245                async_answer_0(chandle, EREFUSED);
     246                async_answer_0(icall_handle, EREFUSED);
    247247                return;
    248248        }
    249249
    250250        if (size != sizeof(vbd_part_info_t)) {
    251                 async_answer_0(callid, EINVAL);
    252                 async_answer_0(iid, EINVAL);
    253                 return;
    254         }
    255 
    256         rc = async_data_read_finalize(callid, &pinfo,
     251                async_answer_0(chandle, EINVAL);
     252                async_answer_0(icall_handle, EINVAL);
     253                return;
     254        }
     255
     256        rc = async_data_read_finalize(chandle, &pinfo,
    257257            min(size, sizeof(pinfo)));
    258258        if (rc != EOK) {
    259                 async_answer_0(callid, rc);
    260                 async_answer_0(iid, rc);
    261                 return;
    262         }
    263 
    264         async_answer_0(iid, EOK);
    265 }
    266 
    267 static void vbds_part_create_srv(cap_call_handle_t iid, ipc_call_t *icall)
     259                async_answer_0(chandle, rc);
     260                async_answer_0(icall_handle, rc);
     261                return;
     262        }
     263
     264        async_answer_0(icall_handle, EOK);
     265}
     266
     267static void vbds_part_create_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
    268268{
    269269        service_id_t disk_sid;
    … …  
    276276        disk_sid = IPC_GET_ARG1(*icall);
    277277
    278         cap_call_handle_t callid;
    279         size_t size;
    280         if (!async_data_write_receive(&callid, &size)) {
    281                 async_answer_0(callid, EREFUSED);
    282                 async_answer_0(iid, EREFUSED);
     278        cap_call_handle_t chandle;
     279        size_t size;
     280        if (!async_data_write_receive(&chandle, &size)) {
     281                async_answer_0(chandle, EREFUSED);
     282                async_answer_0(icall_handle, EREFUSED);
    283283                return;
    284284        }
    285285
    286286        if (size != sizeof(vbd_part_spec_t)) {
    287                 async_answer_0(callid, EINVAL);
    288                 async_answer_0(iid, EINVAL);
    289                 return;
    290         }
    291 
    292         rc = async_data_write_finalize(callid, &pspec, sizeof(vbd_part_spec_t));
    293         if (rc != EOK) {
    294                 async_answer_0(callid, rc);
    295                 async_answer_0(iid, rc);
     287                async_answer_0(chandle, EINVAL);
     288                async_answer_0(icall_handle, EINVAL);
     289                return;
     290        }
     291
     292        rc = async_data_write_finalize(chandle, &pspec, sizeof(vbd_part_spec_t));
     293        if (rc != EOK) {
     294                async_answer_0(chandle, rc);
     295                async_answer_0(icall_handle, rc);
    296296                return;
    297297        }
    … …  
    299299        rc = vbds_part_create(disk_sid, &pspec, &part);
    300300        if (rc != EOK) {
    301                 async_answer_0(iid, rc);
    302                 return;
    303         }
    304 
    305         async_answer_1(iid, rc, (sysarg_t)part);
    306 }
    307 
    308 static void vbds_part_delete_srv(cap_call_handle_t iid, ipc_call_t *icall)
     301                async_answer_0(icall_handle, rc);
     302                return;
     303        }
     304
     305        async_answer_1(icall_handle, rc, (sysarg_t)part);
     306}
     307
     308static void vbds_part_delete_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
    309309{
    310310        vbds_part_id_t part;
    … …  
    315315        part = IPC_GET_ARG1(*icall);
    316316        rc = vbds_part_delete(part);
    317         async_answer_0(iid, rc);
    318 }
    319 
    320 static void vbds_suggest_ptype_srv(cap_call_handle_t iid, ipc_call_t *icall)
     317        async_answer_0(icall_handle, rc);
     318}
     319
     320static void vbds_suggest_ptype_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
    321321{
    322322        service_id_t disk_sid;
    … …  
    332332        rc = vbds_suggest_ptype(disk_sid, pcnt, &ptype);
    333333        if (rc != EOK) {
    334                 async_answer_0(iid, rc);
    335                 return;
    336         }
    337 
    338         cap_call_handle_t callid;
    339         size_t size;
    340         if (!async_data_read_receive(&callid, &size)) {
    341                 async_answer_0(callid, EREFUSED);
    342                 async_answer_0(iid, EREFUSED);
     334                async_answer_0(icall_handle, rc);
     335                return;
     336        }
     337
     338        cap_call_handle_t chandle;
     339        size_t size;
     340        if (!async_data_read_receive(&chandle, &size)) {
     341                async_answer_0(chandle, EREFUSED);
     342                async_answer_0(icall_handle, EREFUSED);
    343343                return;
    344344        }
    345345
    346346        if (size != sizeof(label_ptype_t)) {
    347                 async_answer_0(callid, EINVAL);
    348                 async_answer_0(iid, EINVAL);
    349                 return;
    350         }
    351 
    352         rc = async_data_read_finalize(callid, &ptype, sizeof(label_ptype_t));
    353         if (rc != EOK) {
    354                 async_answer_0(callid, rc);
    355                 async_answer_0(iid, rc);
    356                 return;
    357         }
    358 
    359         async_answer_0(iid, EOK);
    360 }
    361 
    362 static void vbds_ctl_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     347                async_answer_0(chandle, EINVAL);
     348                async_answer_0(icall_handle, EINVAL);
     349                return;
     350        }
     351
     352        rc = async_data_read_finalize(chandle, &ptype, sizeof(label_ptype_t));
     353        if (rc != EOK) {
     354                async_answer_0(chandle, rc);
     355                async_answer_0(icall_handle, rc);
     356                return;
     357        }
     358
     359        async_answer_0(icall_handle, EOK);
     360}
     361
     362static void vbds_ctl_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    363363{
    364364        log_msg(LOG_DEFAULT, LVL_DEBUG, "vbds_client_conn()");
    365365
    366366        /* Accept the connection */
    367         async_answer_0(iid, EOK);
     367        async_answer_0(icall_handle, EOK);
    368368
    369369        while (true) {
    370370                ipc_call_t call;
    371                 cap_call_handle_t callid = async_get_call(&call);
     371                cap_call_handle_t chandle = async_get_call(&call);
    372372                sysarg_t method = IPC_GET_IMETHOD(call);
    373373
    374374                if (!method) {
    375375                        /* The other side has hung up */
    376                         async_answer_0(callid, EOK);
     376                        async_answer_0(chandle, EOK);
    377377                        return;
    378378                }
    … …  
    380380                switch (method) {
    381381                case VBD_GET_DISKS:
    382                         vbds_get_disks_srv(callid, &call);
     382                        vbds_get_disks_srv(chandle, &call);
    383383                        break;
    384384                case VBD_DISK_INFO:
    385                         vbds_disk_info_srv(callid, &call);
     385                        vbds_disk_info_srv(chandle, &call);
    386386                        break;
    387387                case VBD_LABEL_CREATE:
    388                         vbds_label_create_srv(callid, &call);
     388                        vbds_label_create_srv(chandle, &call);
    389389                        break;
    390390                case VBD_LABEL_DELETE:
    391                         vbds_label_delete_srv(callid, &call);
     391                        vbds_label_delete_srv(chandle, &call);
    392392                        break;
    393393                case VBD_LABEL_GET_PARTS:
    394                         vbds_label_get_parts_srv(callid, &call);
     394                        vbds_label_get_parts_srv(chandle, &call);
    395395                        break;
    396396                case VBD_PART_GET_INFO:
    397                         vbds_part_get_info_srv(callid, &call);
     397                        vbds_part_get_info_srv(chandle, &call);
    398398                        break;
    399399                case VBD_PART_CREATE:
    400                         vbds_part_create_srv(callid, &call);
     400                        vbds_part_create_srv(chandle, &call);
    401401                        break;
    402402                case VBD_PART_DELETE:
    403                         vbds_part_delete_srv(callid, &call);
     403                        vbds_part_delete_srv(chandle, &call);
    404404                        break;
    405405                case VBD_SUGGEST_PTYPE:
    406                         vbds_suggest_ptype_srv(callid, &call);
     406                        vbds_suggest_ptype_srv(chandle, &call);
    407407                        break;
    408408                default:
    409                         async_answer_0(callid, EINVAL);
     409                        async_answer_0(chandle, EINVAL);
    410410                }
    411411        }
    412412}
    413413
    414 static void vbds_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     414static void vbds_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    415415{
    416416        service_id_t sid;
    … …  
    421421
    422422        if (sid == ctl_sid)
    423                 vbds_ctl_conn(iid, icall, arg);
     423                vbds_ctl_conn(icall_handle, icall, arg);
    424424        else
    425                 vbds_bd_conn(iid, icall, arg);
     425                vbds_bd_conn(icall_handle, icall, arg);
    426426}
    427427
Note: See TracChangeset for help on using the changeset viewer.