Changeset 984a9ba in mainline for uspace/srv/volsrv/volsrv.c


Ignore:
Timestamp:
2018-07-05T09:34:09Z (6 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/volsrv/volsrv.c

    r76f566d r984a9ba  
    5252#define NAME  "volsrv"
    5353
    54 static void vol_client_conn(cap_call_handle_t, ipc_call_t *, void *);
     54static void vol_client_conn(ipc_call_t *, void *);
    5555
    5656static errno_t vol_init(void)
    … …  
    8585}
    8686
    87 static void vol_get_parts_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
    88 {
    89         cap_call_handle_t chandle;
     87static void vol_get_parts_srv(ipc_call_t *icall)
     88{
     89        ipc_call_t call;
    9090        size_t size;
    9191        size_t act_size;
    9292        errno_t rc;
    9393
    94         if (!async_data_read_receive(&chandle, &size)) {
    95                 async_answer_0(chandle, EREFUSED);
    96                 async_answer_0(icall_handle, EREFUSED);
     94        if (!async_data_read_receive(&call, &size)) {
     95                async_answer_0(&call, EREFUSED);
     96                async_answer_0(icall, EREFUSED);
    9797                return;
    9898        }
    … …  
    100100        service_id_t *id_buf = (service_id_t *) malloc(size);
    101101        if (id_buf == NULL) {
    102                 async_answer_0(chandle, ENOMEM);
    103                 async_answer_0(icall_handle, ENOMEM);
     102                async_answer_0(&call, ENOMEM);
     103                async_answer_0(icall, ENOMEM);
    104104                return;
    105105        }
    … …  
    107107        rc = vol_part_get_ids(id_buf, size, &act_size);
    108108        if (rc != EOK) {
    109                 async_answer_0(chandle, rc);
    110                 async_answer_0(icall_handle, rc);
    111                 return;
    112         }
    113 
    114         errno_t retval = async_data_read_finalize(chandle, id_buf, size);
     109                async_answer_0(&call, rc);
     110                async_answer_0(icall, rc);
     111                return;
     112        }
     113
     114        errno_t retval = async_data_read_finalize(&call, id_buf, size);
    115115        free(id_buf);
    116116
    117         async_answer_1(icall_handle, retval, act_size);
    118 }
    119 
    120 static void vol_part_add_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
     117        async_answer_1(icall, retval, act_size);
     118}
     119
     120static void vol_part_add_srv(ipc_call_t *icall)
    121121{
    122122        service_id_t sid;
    … …  
    127127        rc = vol_part_add(sid);
    128128        if (rc != EOK) {
    129                 async_answer_0(icall_handle, rc);
    130                 return;
    131         }
    132 
    133         async_answer_0(icall_handle, EOK);
    134 }
    135 
    136 static void vol_part_info_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
     129                async_answer_0(icall, rc);
     130                return;
     131        }
     132
     133        async_answer_0(icall, EOK);
     134}
     135
     136static void vol_part_info_srv(ipc_call_t *icall)
    137137{
    138138        service_id_t sid;
    … …  
    146146        rc = vol_part_find_by_id_ref(sid, &part);
    147147        if (rc != EOK) {
    148                 async_answer_0(icall_handle, ENOENT);
     148                async_answer_0(icall, ENOENT);
    149149                return;
    150150        }
    … …  
    152152        rc = vol_part_get_info(part, &pinfo);
    153153        if (rc != EOK) {
    154                 async_answer_0(icall_handle, EIO);
    155                 goto error;
    156         }
    157 
    158         cap_call_handle_t chandle;
     154                async_answer_0(icall, EIO);
     155                goto error;
     156        }
     157
     158        ipc_call_t call;
    159159        size_t size;
    160         if (!async_data_read_receive(&chandle, &size)) {
    161                 async_answer_0(chandle, EREFUSED);
    162                 async_answer_0(icall_handle, EREFUSED);
     160        if (!async_data_read_receive(&call, &size)) {
     161                async_answer_0(&call, EREFUSED);
     162                async_answer_0(icall, EREFUSED);
    163163                goto error;
    164164        }
    165165
    166166        if (size != sizeof(vol_part_info_t)) {
    167                 async_answer_0(chandle, EINVAL);
    168                 async_answer_0(icall_handle, EINVAL);
    169                 goto error;
    170         }
    171 
    172         rc = async_data_read_finalize(chandle, &pinfo,
     167                async_answer_0(&call, EINVAL);
     168                async_answer_0(icall, EINVAL);
     169                goto error;
     170        }
     171
     172        rc = async_data_read_finalize(&call, &pinfo,
    173173            min(size, sizeof(pinfo)));
    174174        if (rc != EOK) {
    175                 async_answer_0(chandle, rc);
    176                 async_answer_0(icall_handle, rc);
    177                 goto error;
    178         }
    179 
    180         async_answer_0(icall_handle, EOK);
     175                async_answer_0(&call, rc);
     176                async_answer_0(icall, rc);
     177                goto error;
     178        }
     179
     180        async_answer_0(icall, EOK);
    181181error:
    182182        vol_part_del_ref(part);
    183183}
    184184
    185 static void vol_part_eject_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
     185static void vol_part_eject_srv(ipc_call_t *icall)
    186186{
    187187        service_id_t sid;
    … …  
    194194        rc = vol_part_find_by_id_ref(sid, &part);
    195195        if (rc != EOK) {
    196                 async_answer_0(icall_handle, ENOENT);
     196                async_answer_0(icall, ENOENT);
    197197                goto error;
    198198        }
    … …  
    200200        rc = vol_part_eject_part(part);
    201201        if (rc != EOK) {
    202                 async_answer_0(icall_handle, EIO);
    203                 goto error;
    204         }
    205 
    206         async_answer_0(icall_handle, EOK);
     202                async_answer_0(icall, EIO);
     203                goto error;
     204        }
     205
     206        async_answer_0(icall, EOK);
    207207error:
    208208        vol_part_del_ref(part);
    209209}
    210210
    211 static void vol_part_empty_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
     211static void vol_part_empty_srv(ipc_call_t *icall)
    212212{
    213213        service_id_t sid;
    … …  
    220220        rc = vol_part_find_by_id_ref(sid, &part);
    221221        if (rc != EOK) {
    222                 async_answer_0(icall_handle, ENOENT);
     222                async_answer_0(icall, ENOENT);
    223223                return;
    224224        }
    … …  
    226226        rc = vol_part_empty_part(part);
    227227        if (rc != EOK) {
    228                 async_answer_0(icall_handle, EIO);
    229                 goto error;
    230         }
    231 
    232         async_answer_0(icall_handle, EOK);
     228                async_answer_0(icall, EIO);
     229                goto error;
     230        }
     231
     232        async_answer_0(icall, EOK);
    233233error:
    234234        vol_part_del_ref(part);
    235235}
    236236
    237 static void vol_part_get_lsupp_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
     237static void vol_part_get_lsupp_srv(ipc_call_t *icall)
    238238{
    239239        vol_fstype_t fstype;
    … …  
    247247        volsrv_part_get_lsupp(fstype, &vlsupp);
    248248
    249         cap_call_handle_t chandle;
     249        ipc_call_t call;
    250250        size_t size;
    251         if (!async_data_read_receive(&chandle, &size)) {
    252                 async_answer_0(chandle, EREFUSED);
    253                 async_answer_0(icall_handle, EREFUSED);
     251        if (!async_data_read_receive(&call, &size)) {
     252                async_answer_0(&call, EREFUSED);
     253                async_answer_0(icall, EREFUSED);
    254254                return;
    255255        }
    256256
    257257        if (size != sizeof(vol_label_supp_t)) {
    258                 async_answer_0(chandle, EINVAL);
    259                 async_answer_0(icall_handle, EINVAL);
    260                 return;
    261         }
    262 
    263         rc = async_data_read_finalize(chandle, &vlsupp,
     258                async_answer_0(&call, EINVAL);
     259                async_answer_0(icall, EINVAL);
     260                return;
     261        }
     262
     263        rc = async_data_read_finalize(&call, &vlsupp,
    264264            min(size, sizeof(vlsupp)));
    265265        if (rc != EOK) {
    266                 async_answer_0(chandle, rc);
    267                 async_answer_0(icall_handle, rc);
    268                 return;
    269         }
    270 
    271         async_answer_0(icall_handle, EOK);
    272 }
    273 
    274 
    275 static void vol_part_mkfs_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
     266                async_answer_0(&call, rc);
     267                async_answer_0(icall, rc);
     268                return;
     269        }
     270
     271        async_answer_0(icall, EOK);
     272}
     273
     274
     275static void vol_part_mkfs_srv(ipc_call_t *icall)
    276276{
    277277        service_id_t sid;
    … …  
    289289            0, NULL);
    290290        if (rc != EOK) {
    291                 async_answer_0(icall_handle, rc);
     291                async_answer_0(icall, rc);
    292292                return;
    293293        }
    … …  
    301301        if (rc != EOK) {
    302302                free(label);
    303                 async_answer_0(icall_handle, ENOENT);
     303                async_answer_0(icall, ENOENT);
    304304                return;
    305305        }
    … …  
    308308        if (rc != EOK) {
    309309                free(label);
    310                 async_answer_0(icall_handle, rc);
     310                async_answer_0(icall, rc);
    311311                vol_part_del_ref(part);
    312312                return;
    … …  
    314314
    315315        free(label);
    316         async_answer_0(icall_handle, EOK);
    317 }
    318 
    319 static void vol_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     316        async_answer_0(icall, EOK);
     317}
     318
     319static void vol_client_conn(ipc_call_t *icall, void *arg)
    320320{
    321321        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_client_conn()");
    322322
    323323        /* Accept the connection */
    324         async_answer_0(icall_handle, EOK);
     324        async_answer_0(icall, EOK);
    325325
    326326        while (true) {
    327327                ipc_call_t call;
    328                 cap_call_handle_t chandle = async_get_call(&call);
     328                async_get_call(&call);
    329329                sysarg_t method = IPC_GET_IMETHOD(call);
    330330
    331331                if (!method) {
    332332                        /* The other side has hung up */
    333                         async_answer_0(chandle, EOK);
     333                        async_answer_0(&call, EOK);
    334334                        return;
    335335                }
    … …  
    337337                switch (method) {
    338338                case VOL_GET_PARTS:
    339                         vol_get_parts_srv(chandle, &call);
     339                        vol_get_parts_srv(&call);
    340340                        break;
    341341                case VOL_PART_ADD:
    342                         vol_part_add_srv(chandle, &call);
     342                        vol_part_add_srv(&call);
    343343                        break;
    344344                case VOL_PART_INFO:
    345                         vol_part_info_srv(chandle, &call);
     345                        vol_part_info_srv(&call);
    346346                        break;
    347347                case VOL_PART_EJECT:
    348                         vol_part_eject_srv(chandle, &call);
     348                        vol_part_eject_srv(&call);
    349349                        break;
    350350                case VOL_PART_EMPTY:
    351                         vol_part_empty_srv(chandle, &call);
     351                        vol_part_empty_srv(&call);
    352352                        break;
    353353                case VOL_PART_LSUPP:
    354                         vol_part_get_lsupp_srv(chandle, &call);
     354                        vol_part_get_lsupp_srv(&call);
    355355                        break;
    356356                case VOL_PART_MKFS:
    357                         vol_part_mkfs_srv(chandle, &call);
     357                        vol_part_mkfs_srv(&call);
    358358                        break;
    359359                default:
    360                         async_answer_0(chandle, EINVAL);
     360                        async_answer_0(&call, EINVAL);
    361361                }
    362362        }
Note: See TracChangeset for help on using the changeset viewer.