Changeset 984a9ba in mainline for uspace/srv/bd/vbd/vbd.c


Ignore:
Timestamp:
2018-07-05T09:34:09Z (7 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
63d46341
Parents:
76f566d
Message:

do not expose the call capability handler from the async framework

Keep the call capability handler encapsulated within the async framework
and do not expose it explicitly via its API. Use the pointer to
ipc_call_t as the sole object identifying an IPC call in the code that
uses the async framework.

This plugs a major leak in the abstraction and also simplifies both the
async framework (slightly) and all IPC servers.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/bd/vbd/vbd.c

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