Changeset 984a9ba in mainline for uspace/lib/c/generic/io/con_srv.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/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        }
Note: See TracChangeset for help on using the changeset viewer.