Changeset 984a9ba in mainline for uspace/lib/c/generic/io


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.

Location:
uspace/lib/c/generic/io
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/io/chardev_srv.c

    r76f566d r984a9ba  
    4343static chardev_srv_t *chardev_srv_create(chardev_srvs_t *);
    4444
    45 static void chardev_read_srv(chardev_srv_t *srv, cap_call_handle_t chandle,
    46     ipc_call_t *call)
     45static void chardev_read_srv(chardev_srv_t *srv, ipc_call_t *icall)
    4746{
    4847        void *buf;
    … …  
    5049        size_t nread;
    5150        errno_t rc;
    52         cap_call_handle_t rcall_handle;
    5351
    54         if (!async_data_read_receive(&rcall_handle, &size)) {
    55                 async_answer_0(chandle, EINVAL);
     52        ipc_call_t call;
     53        if (!async_data_read_receive(&call, &size)) {
     54                async_answer_0(icall, EINVAL);
    5655                return;
    5756        }
    … …  
    5958        buf = malloc(size);
    6059        if (buf == NULL) {
    61                 async_answer_0(rcall_handle, ENOMEM);
    62                 async_answer_0(chandle, ENOMEM);
     60                async_answer_0(&call, ENOMEM);
     61                async_answer_0(icall, ENOMEM);
    6362                return;
    6463        }
    6564
    6665        if (srv->srvs->ops->read == NULL) {
    67                 async_answer_0(rcall_handle, ENOTSUP);
    68                 async_answer_0(chandle, ENOTSUP);
     66                async_answer_0(&call, ENOTSUP);
     67                async_answer_0(icall, ENOTSUP);
    6968                free(buf);
    7069                return;
    … …  
    7372        rc = srv->srvs->ops->read(srv, buf, size, &nread);
    7473        if (rc != EOK && nread == 0) {
    75                 async_answer_0(rcall_handle, rc);
    76                 async_answer_0(chandle, rc);
     74                async_answer_0(&call, rc);
     75                async_answer_0(icall, rc);
    7776                free(buf);
    7877                return;
    7978        }
    8079
    81         async_data_read_finalize(rcall_handle, buf, nread);
     80        async_data_read_finalize(&call, buf, nread);
    8281
    8382        free(buf);
    84         async_answer_2(chandle, EOK, (sysarg_t) rc, nread);
     83        async_answer_2(icall, EOK, (sysarg_t) rc, nread);
    8584}
    8685
    87 static void chardev_write_srv(chardev_srv_t *srv, cap_call_handle_t chandle,
    88     ipc_call_t *call)
     86static void chardev_write_srv(chardev_srv_t *srv, ipc_call_t *icall)
    8987{
    9088        void *data;
    … …  
    9593        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    9694        if (rc != EOK) {
    97                 async_answer_0(chandle, rc);
     95                async_answer_0(icall, rc);
    9896                return;
    9997        }
    10098
    10199        if (srv->srvs->ops->write == NULL) {
    102                 async_answer_0(chandle, ENOTSUP);
     100                async_answer_0(icall, ENOTSUP);
    103101                return;
    104102        }
    … …  
    107105        free(data);
    108106        if (rc != EOK && nwr == 0) {
    109                 async_answer_0(chandle, rc);
     107                async_answer_0(icall, rc);
    110108                return;
    111109        }
    112110
    113         async_answer_2(chandle, EOK, (sysarg_t) rc, nwr);
     111        async_answer_2(icall, EOK, (sysarg_t) rc, nwr);
    114112}
    115113
    … …  
    132130}
    133131
    134 errno_t chardev_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, chardev_srvs_t *srvs)
     132errno_t chardev_conn(ipc_call_t *icall, chardev_srvs_t *srvs)
    135133{
    136134        chardev_srv_t *srv;
    … …  
    138136
    139137        /* Accept the connection */
    140         async_answer_0(icall_handle, EOK);
     138        async_answer_0(icall, EOK);
    141139
    142140        srv = chardev_srv_create(srvs);
    … …  
    152150        while (true) {
    153151                ipc_call_t call;
    154                 cap_call_handle_t chandle = async_get_call(&call);
     152                async_get_call(&call);
    155153                sysarg_t method = IPC_GET_IMETHOD(call);
    156154
    157155                if (!method) {
    158156                        /* The other side has hung up */
    159                         async_answer_0(chandle, EOK);
     157                        async_answer_0(&call, EOK);
    160158                        break;
    161159                }
    … …  
    163161                switch (method) {
    164162                case CHARDEV_READ:
    165                         chardev_read_srv(srv, chandle, &call);
     163                        chardev_read_srv(srv, &call);
    166164                        break;
    167165                case CHARDEV_WRITE:
    168                         chardev_write_srv(srv, chandle, &call);
     166                        chardev_write_srv(srv, &call);
    169167                        break;
    170168                default:
    171169                        if (srv->srvs->ops->def_handler != NULL)
    172                                 srv->srvs->ops->def_handler(srv, chandle, &call);
     170                                srv->srvs->ops->def_handler(srv, &call);
    173171                        else
    174                                 async_answer_0(chandle, ENOTSUP);
     172                                async_answer_0(&call, ENOTSUP);
    175173                }
    176174        }

  • uspace/lib/c/generic/io/con_srv.c

    r76f566d r984a9ba  
    4242#include <io/con_srv.h>
    4343
    44 static errno_t console_ev_encode(cons_event_t *event, ipc_call_t *call)
    45 {
    46         IPC_SET_ARG1(*call, event->type);
     44static errno_t console_ev_encode(cons_event_t *event, ipc_call_t *icall)
     45{
     46        IPC_SET_ARG1(*icall, event->type);
    4747
    4848        switch (event->type) {
    4949        case CEV_KEY:
    50                 IPC_SET_ARG2(*call, event->ev.key.type);
    51                 IPC_SET_ARG3(*call, event->ev.key.key);
    52                 IPC_SET_ARG4(*call, event->ev.key.mods);
    53                 IPC_SET_ARG5(*call, event->ev.key.c);
     50                IPC_SET_ARG2(*icall, event->ev.key.type);
     51                IPC_SET_ARG3(*icall, event->ev.key.key);
     52                IPC_SET_ARG4(*icall, event->ev.key.mods);
     53                IPC_SET_ARG5(*icall, event->ev.key.c);
    5454                break;
    5555        case CEV_POS:
    56                 IPC_SET_ARG2(*call, (event->ev.pos.pos_id << 16) | (event->ev.pos.type & 0xffff));
    57                 IPC_SET_ARG3(*call, event->ev.pos.btn_num);
    58                 IPC_SET_ARG4(*call, event->ev.pos.hpos);
    59                 IPC_SET_ARG5(*call, event->ev.pos.vpos);
     56                IPC_SET_ARG2(*icall, (event->ev.pos.pos_id << 16) | (event->ev.pos.type & 0xffff));
     57                IPC_SET_ARG3(*icall, event->ev.pos.btn_num);
     58                IPC_SET_ARG4(*icall, event->ev.pos.hpos);
     59                IPC_SET_ARG5(*icall, event->ev.pos.vpos);
    6060                break;
    6161        default:
    … …  
    6666}
    6767
    68 static void con_read_srv(con_srv_t *srv, cap_call_handle_t chandle,
    69     ipc_call_t *call)
     68static void con_read_srv(con_srv_t *srv, ipc_call_t *icall)
    7069{
    7170        void *buf;
    7271        size_t size;
    7372        errno_t rc;
    74         cap_call_handle_t rcall_handle;
    75 
    76         if (!async_data_read_receive(&rcall_handle, &size)) {
    77                 async_answer_0(chandle, EINVAL);
     73
     74        ipc_call_t call;
     75        if (!async_data_read_receive(&call, &size)) {
     76                async_answer_0(icall, EINVAL);
    7877                return;
    7978        }
    … …  
    8180        buf = malloc(size);
    8281        if (buf == NULL) {
    83                 async_answer_0(rcall_handle, ENOMEM);
    84                 async_answer_0(chandle, ENOMEM);
     82                async_answer_0(&call, ENOMEM);
     83                async_answer_0(icall, ENOMEM);
    8584                return;
    8685        }
    8786
    8887        if (srv->srvs->ops->read == NULL) {
    89                 async_answer_0(rcall_handle, ENOTSUP);
    90                 async_answer_0(chandle, ENOTSUP);
     88                async_answer_0(&call, ENOTSUP);
     89                async_answer_0(icall, ENOTSUP);
    9190                free(buf);
    9291                return;
    … …  
    9695        rc = srv->srvs->ops->read(srv, buf, size, &nread);
    9796        if (rc != EOK) {
    98                 async_answer_0(rcall_handle, rc);
    99                 async_answer_0(chandle, rc);
     97                async_answer_0(&call, rc);
     98                async_answer_0(icall, rc);
    10099                free(buf);
    101100                return;
    102101        }
    103102
    104         async_data_read_finalize(rcall_handle, buf, nread);
     103        async_data_read_finalize(&call, buf, nread);
    105104        free(buf);
    106105
    107         async_answer_1(chandle, EOK, nread);
    108 }
    109 
    110 static void con_write_srv(con_srv_t *srv, cap_call_handle_t chandle,
    111     ipc_call_t *call)
     106        async_answer_1(icall, EOK, nread);
     107}
     108
     109static void con_write_srv(con_srv_t *srv, ipc_call_t *icall)
    112110{
    113111        void *data;
    … …  
    117115        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    118116        if (rc != EOK) {
    119                 async_answer_0(chandle, rc);
     117                async_answer_0(icall, rc);
    120118                return;
    121119        }
    122120
    123121        if (srv->srvs->ops->write == NULL) {
    124                 async_answer_0(chandle, ENOTSUP);
     122                async_answer_0(icall, ENOTSUP);
    125123                return;
    126124        }
    … …  
    130128        free(data);
    131129
    132         async_answer_1(chandle, rc, nwritten);
    133 }
    134 
    135 static void con_sync_srv(con_srv_t *srv, cap_call_handle_t chandle,
    136     ipc_call_t *call)
     130        async_answer_1(icall, rc, nwritten);
     131}
     132
     133static void con_sync_srv(con_srv_t *srv, ipc_call_t *icall)
    137134{
    138135        if (srv->srvs->ops->sync == NULL) {
    139                 async_answer_0(chandle, ENOTSUP);
     136                async_answer_0(icall, ENOTSUP);
    140137                return;
    141138        }
    142139
    143140        srv->srvs->ops->sync(srv);
    144         async_answer_0(chandle, EOK);
    145 }
    146 
    147 static void con_clear_srv(con_srv_t *srv, cap_call_handle_t chandle,
    148     ipc_call_t *call)
     141        async_answer_0(icall, EOK);
     142}
     143
     144static void con_clear_srv(con_srv_t *srv, ipc_call_t *icall)
    149145{
    150146        if (srv->srvs->ops->clear == NULL) {
    151                 async_answer_0(chandle, ENOTSUP);
     147                async_answer_0(icall, ENOTSUP);
    152148                return;
    153149        }
    154150
    155151        srv->srvs->ops->clear(srv);
    156         async_answer_0(chandle, EOK);
    157 }
    158 
    159 static void con_set_pos_srv(con_srv_t *srv, cap_call_handle_t chandle,
    160     ipc_call_t *call)
     152        async_answer_0(icall, EOK);
     153}
     154
     155static void con_set_pos_srv(con_srv_t *srv, ipc_call_t *icall)
    161156{
    162157        sysarg_t col;
    163158        sysarg_t row;
    164159
    165         col = IPC_GET_ARG1(*call);
    166         row = IPC_GET_ARG2(*call);
     160        col = IPC_GET_ARG1(*icall);
     161        row = IPC_GET_ARG2(*icall);
    167162
    168163        if (srv->srvs->ops->set_pos == NULL) {
    169                 async_answer_0(chandle, ENOTSUP);
     164                async_answer_0(icall, ENOTSUP);
    170165                return;
    171166        }
    172167
    173168        srv->srvs->ops->set_pos(srv, col, row);
    174         async_answer_0(chandle, EOK);
    175 }
    176 
    177 static void con_get_pos_srv(con_srv_t *srv, cap_call_handle_t chandle,
    178     ipc_call_t *call)
     169        async_answer_0(icall, EOK);
     170}
     171
     172static void con_get_pos_srv(con_srv_t *srv, ipc_call_t *icall)
    179173{
    180174        errno_t rc;
    … …  
    183177
    184178        if (srv->srvs->ops->get_pos == NULL) {
    185                 async_answer_0(chandle, ENOTSUP);
     179                async_answer_0(icall, ENOTSUP);
    186180                return;
    187181        }
    188182
    189183        rc = srv->srvs->ops->get_pos(srv, &col, &row);
    190         async_answer_2(chandle, rc, col, row);
    191 }
    192 
    193 static void con_get_size_srv(con_srv_t *srv, cap_call_handle_t chandle,
    194     ipc_call_t *call)
     184        async_answer_2(icall, rc, col, row);
     185}
     186
     187static void con_get_size_srv(con_srv_t *srv, ipc_call_t *icall)
    195188{
    196189        errno_t rc;
    … …  
    199192
    200193        if (srv->srvs->ops->get_size == NULL) {
    201                 async_answer_0(chandle, ENOTSUP);
     194                async_answer_0(icall, ENOTSUP);
    202195                return;
    203196        }
    204197
    205198        rc = srv->srvs->ops->get_size(srv, &cols, &rows);
    206         async_answer_2(chandle, rc, cols, rows);
    207 }
    208 
    209 static void con_get_color_cap_srv(con_srv_t *srv, cap_call_handle_t chandle,
    210     ipc_call_t *call)
     199        async_answer_2(icall, rc, cols, rows);
     200}
     201
     202static void con_get_color_cap_srv(con_srv_t *srv, ipc_call_t *icall)
    211203{
    212204        errno_t rc;
    … …  
    214206
    215207        if (srv->srvs->ops->get_color_cap == NULL) {
    216                 async_answer_0(chandle, ENOTSUP);
     208                async_answer_0(icall, ENOTSUP);
    217209                return;
    218210        }
    219211
    220212        rc = srv->srvs->ops->get_color_cap(srv, &ccap);
    221         async_answer_1(chandle, rc, (sysarg_t)ccap);
    222 }
    223 
    224 static void con_set_style_srv(con_srv_t *srv, cap_call_handle_t chandle,
    225     ipc_call_t *call)
     213        async_answer_1(icall, rc, (sysarg_t)ccap);
     214}
     215
     216static void con_set_style_srv(con_srv_t *srv, ipc_call_t *icall)
    226217{
    227218        console_style_t style;
    228219
    229         style = IPC_GET_ARG1(*call);
     220        style = IPC_GET_ARG1(*icall);
    230221
    231222        if (srv->srvs->ops->set_style == NULL) {
    232                 async_answer_0(chandle, ENOTSUP);
     223                async_answer_0(icall, ENOTSUP);
    233224                return;
    234225        }
    235226
    236227        srv->srvs->ops->set_style(srv, style);
    237         async_answer_0(chandle, EOK);
    238 }
    239 
    240 static void con_set_color_srv(con_srv_t *srv, cap_call_handle_t chandle,
    241     ipc_call_t *call)
     228        async_answer_0(icall, EOK);
     229}
     230
     231static void con_set_color_srv(con_srv_t *srv, ipc_call_t *icall)
    242232{
    243233        console_color_t bgcolor;
    … …  
    245235        console_color_attr_t flags;
    246236
    247         bgcolor = IPC_GET_ARG1(*call);
    248         fgcolor = IPC_GET_ARG2(*call);
    249         flags = IPC_GET_ARG3(*call);
     237        bgcolor = IPC_GET_ARG1(*icall);
     238        fgcolor = IPC_GET_ARG2(*icall);
     239        flags = IPC_GET_ARG3(*icall);
    250240
    251241        if (srv->srvs->ops->set_color == NULL) {
    252                 async_answer_0(chandle, ENOTSUP);
     242                async_answer_0(icall, ENOTSUP);
    253243                return;
    254244        }
    255245
    256246        srv->srvs->ops->set_color(srv, bgcolor, fgcolor, flags);
    257         async_answer_0(chandle, EOK);
    258 }
    259 
    260 static void con_set_rgb_color_srv(con_srv_t *srv, cap_call_handle_t chandle,
    261     ipc_call_t *call)
     247        async_answer_0(icall, EOK);
     248}
     249
     250static void con_set_rgb_color_srv(con_srv_t *srv, ipc_call_t *icall)
    262251{
    263252        pixel_t bgcolor;
    264253        pixel_t fgcolor;
    265254
    266         bgcolor = IPC_GET_ARG1(*call);
    267         fgcolor = IPC_GET_ARG2(*call);
     255        bgcolor = IPC_GET_ARG1(*icall);
     256        fgcolor = IPC_GET_ARG2(*icall);
    268257
    269258        if (srv->srvs->ops->set_rgb_color == NULL) {
    270                 async_answer_0(chandle, ENOTSUP);
     259                async_answer_0(icall, ENOTSUP);
    271260                return;
    272261        }
    273262
    274263        srv->srvs->ops->set_rgb_color(srv, bgcolor, fgcolor);
    275         async_answer_0(chandle, EOK);
    276 }
    277 
    278 static void con_set_cursor_visibility_srv(con_srv_t *srv, cap_call_handle_t chandle,
    279     ipc_call_t *call)
     264        async_answer_0(icall, EOK);
     265}
     266
     267static void con_set_cursor_visibility_srv(con_srv_t *srv, ipc_call_t *icall)
    280268{
    281269        bool show;
    282270
    283         show = IPC_GET_ARG1(*call);
     271        show = IPC_GET_ARG1(*icall);
    284272
    285273        if (srv->srvs->ops->set_cursor_visibility == NULL) {
    286                 async_answer_0(chandle, ENOTSUP);
     274                async_answer_0(icall, ENOTSUP);
    287275                return;
    288276        }
    289277
    290278        srv->srvs->ops->set_cursor_visibility(srv, show);
    291         async_answer_0(chandle, EOK);
    292 }
    293 
    294 static void con_get_event_srv(con_srv_t *srv, cap_call_handle_t chandle,
    295     ipc_call_t *call)
     279        async_answer_0(icall, EOK);
     280}
     281
     282static void con_get_event_srv(con_srv_t *srv, ipc_call_t *icall)
    296283{
    297284        errno_t rc;
    … …  
    300287
    301288        if (srv->srvs->ops->get_event == NULL) {
    302                 async_answer_0(chandle, ENOTSUP);
     289                async_answer_0(icall, ENOTSUP);
    303290                return;
    304291        }
    … …  
    306293        rc = srv->srvs->ops->get_event(srv, &event);
    307294        if (rc != EOK) {
    308                 async_answer_0(chandle, rc);
     295                async_answer_0(icall, rc);
    309296                return;
    310297        }
    … …  
    312299        rc = console_ev_encode(&event, &result);
    313300        if (rc != EOK) {
    314                 async_answer_0(chandle, rc);
    315                 return;
    316         }
    317 
    318         async_answer_5(chandle, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
     301                async_answer_0(icall, rc);
     302                return;
     303        }
     304
     305        async_answer_5(icall, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
    319306            IPC_GET_ARG3(result), IPC_GET_ARG4(result), IPC_GET_ARG5(result));
    320307}
    … …  
    340327}
    341328
    342 errno_t con_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, con_srvs_t *srvs)
     329errno_t con_conn(ipc_call_t *icall, con_srvs_t *srvs)
    343330{
    344331        con_srv_t *srv;
    … …  
    346333
    347334        /* Accept the connection */
    348         async_answer_0(icall_handle, EOK);
     335        async_answer_0(icall, EOK);
    349336
    350337        srv = con_srv_create(srvs);
    … …  
    360347        while (true) {
    361348                ipc_call_t call;
    362                 cap_call_handle_t chandle = 0;
    363 
    364                 while (chandle == 0) {
     349                bool received = false;
     350
     351                while (!received) {
    365352                        /* XXX Need to be able to abort immediately */
    366                         chandle = async_get_call_timeout(&call,
     353                        received = async_get_call_timeout(&call,
    367354                            srvs->abort_timeout);
    368355
    369356                        if (srv->srvs->aborted) {
    370                                 if (chandle != 0)
    371                                         async_answer_0(chandle, EINTR);
     357                                if (received)
     358                                        async_answer_0(&call, EINTR);
    372359                                break;
    373360                        }
    374361                }
    375362
    376                 if (chandle == 0)
     363                if (!received)
    377364                        break;
    378365
    … …  
    381368                if (!method) {
    382369                        /* The other side has hung up */
    383                         async_answer_0(chandle, EOK);
     370                        async_answer_0(&call, EOK);
    384371                        break;
    385372                }
    … …  
    387374                switch (method) {
    388375                case VFS_OUT_READ:
    389                         con_read_srv(srv, chandle, &call);
     376                        con_read_srv(srv, &call);
    390377                        break;
    391378                case VFS_OUT_WRITE:
    392                         con_write_srv(srv, chandle, &call);
     379                        con_write_srv(srv, &call);
    393380                        break;
    394381                case VFS_OUT_SYNC:
    395                         con_sync_srv(srv, chandle, &call);
     382                        con_sync_srv(srv, &call);
    396383                        break;
    397384                case CONSOLE_CLEAR:
    398                         con_clear_srv(srv, chandle, &call);
     385                        con_clear_srv(srv, &call);
    399386                        break;
    400387                case CONSOLE_SET_POS:
    401                         con_set_pos_srv(srv, chandle, &call);
     388                        con_set_pos_srv(srv, &call);
    402389                        break;
    403390                case CONSOLE_GET_POS:
    404                         con_get_pos_srv(srv, chandle, &call);
     391                        con_get_pos_srv(srv, &call);
    405392                        break;
    406393                case CONSOLE_GET_SIZE:
    407                         con_get_size_srv(srv, chandle, &call);
     394                        con_get_size_srv(srv, &call);
    408395                        break;
    409396                case CONSOLE_GET_COLOR_CAP:
    410                         con_get_color_cap_srv(srv, chandle, &call);
     397                        con_get_color_cap_srv(srv, &call);
    411398                        break;
    412399                case CONSOLE_SET_STYLE:
    413                         con_set_style_srv(srv, chandle, &call);
     400                        con_set_style_srv(srv, &call);
    414401                        break;
    415402                case CONSOLE_SET_COLOR:
    416                         con_set_color_srv(srv, chandle, &call);
     403                        con_set_color_srv(srv, &call);
    417404                        break;
    418405                case CONSOLE_SET_RGB_COLOR:
    419                         con_set_rgb_color_srv(srv, chandle, &call);
     406                        con_set_rgb_color_srv(srv, &call);
    420407                        break;
    421408                case CONSOLE_SET_CURSOR_VISIBILITY:
    422                         con_set_cursor_visibility_srv(srv, chandle, &call);
     409                        con_set_cursor_visibility_srv(srv, &call);
    423410                        break;
    424411                case CONSOLE_GET_EVENT:
    425                         con_get_event_srv(srv, chandle, &call);
     412                        con_get_event_srv(srv, &call);
    426413                        break;
    427414                default:
    428                         async_answer_0(chandle, ENOTSUP);
     415                        async_answer_0(&call, ENOTSUP);
    429416                }
    430417        }

  • uspace/lib/c/generic/io/input.c

    r76f566d r984a9ba  
    4343#include <stdlib.h>
    4444
    45 static void input_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
     45static void input_cb_conn(ipc_call_t *icall, void *arg);
    4646
    4747errno_t input_open(async_sess_t *sess, input_ev_ops_t *ev_ops,
    … …  
    9292}
    9393
    94 static void input_ev_active(input_t *input, cap_call_handle_t chandle,
    95     ipc_call_t *call)
     94static void input_ev_active(input_t *input, ipc_call_t *call)
    9695{
    9796        errno_t rc = input->ev_ops->active(input);
    98         async_answer_0(chandle, rc);
    99 }
    100 
    101 static void input_ev_deactive(input_t *input, cap_call_handle_t chandle,
    102     ipc_call_t *call)
     97        async_answer_0(call, rc);
     98}
     99
     100static void input_ev_deactive(input_t *input, ipc_call_t *call)
    103101{
    104102        errno_t rc = input->ev_ops->deactive(input);
    105         async_answer_0(chandle, rc);
    106 }
    107 
    108 static void input_ev_key(input_t *input, cap_call_handle_t chandle,
    109     ipc_call_t *call)
     103        async_answer_0(call, rc);
     104}
     105
     106static void input_ev_key(input_t *input, ipc_call_t *call)
    110107{
    111108        kbd_event_type_t type;
    … …  
    121118
    122119        rc = input->ev_ops->key(input, type, key, mods, c);
    123         async_answer_0(chandle, rc);
    124 }
    125 
    126 static void input_ev_move(input_t *input, cap_call_handle_t chandle,
    127     ipc_call_t *call)
     120        async_answer_0(call, rc);
     121}
     122
     123static void input_ev_move(input_t *input, ipc_call_t *call)
    128124{
    129125        int dx;
    … …  
    135131
    136132        rc = input->ev_ops->move(input, dx, dy);
    137         async_answer_0(chandle, rc);
    138 }
    139 
    140 static void input_ev_abs_move(input_t *input, cap_call_handle_t chandle,
    141     ipc_call_t *call)
     133        async_answer_0(call, rc);
     134}
     135
     136static void input_ev_abs_move(input_t *input, ipc_call_t *call)
    142137{
    143138        unsigned x;
    … …  
    153148
    154149        rc = input->ev_ops->abs_move(input, x, y, max_x, max_y);
    155         async_answer_0(chandle, rc);
    156 }
    157 
    158 static void input_ev_button(input_t *input, cap_call_handle_t chandle,
    159     ipc_call_t *call)
     150        async_answer_0(call, rc);
     151}
     152
     153static void input_ev_button(input_t *input, ipc_call_t *call)
    160154{
    161155        int bnum;
    … …  
    167161
    168162        rc = input->ev_ops->button(input, bnum, press);
    169         async_answer_0(chandle, rc);
    170 }
    171 
    172 static void input_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    173 {
    174         input_t *input = (input_t *)arg;
     163        async_answer_0(call, rc);
     164}
     165
     166static void input_cb_conn(ipc_call_t *icall, void *arg)
     167{
     168        input_t *input = (input_t *) arg;
    175169
    176170        while (true) {
    177171                ipc_call_t call;
    178                 cap_call_handle_t chandle = async_get_call(&call);
     172                async_get_call(&call);
    179173
    180174                if (!IPC_GET_IMETHOD(call)) {
    … …  
    185179                switch (IPC_GET_IMETHOD(call)) {
    186180                case INPUT_EVENT_ACTIVE:
    187                         input_ev_active(input, chandle, &call);
     181                        input_ev_active(input, &call);
    188182                        break;
    189183                case INPUT_EVENT_DEACTIVE:
    190                         input_ev_deactive(input, chandle, &call);
     184                        input_ev_deactive(input, &call);
    191185                        break;
    192186                case INPUT_EVENT_KEY:
    193                         input_ev_key(input, chandle, &call);
     187                        input_ev_key(input, &call);
    194188                        break;
    195189                case INPUT_EVENT_MOVE:
    196                         input_ev_move(input, chandle, &call);
     190                        input_ev_move(input, &call);
    197191                        break;
    198192                case INPUT_EVENT_ABS_MOVE:
    199                         input_ev_abs_move(input, chandle, &call);
     193                        input_ev_abs_move(input, &call);
    200194                        break;
    201195                case INPUT_EVENT_BUTTON:
    202                         input_ev_button(input, chandle, &call);
     196                        input_ev_button(input, &call);
    203197                        break;
    204198                default:
    205                         async_answer_0(chandle, ENOTSUP);
     199                        async_answer_0(&call, ENOTSUP);
    206200                }
    207201        }
Note: See TracChangeset for help on using the changeset viewer.