Changeset 984a9ba in mainline for uspace/srv/hid


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/srv/hid
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/hid/compositor/compositor.c

    r76f566d r984a9ba  
    602602}
    603603
    604 static void comp_window_get_event(window_t *win, cap_call_handle_t icall_handle, ipc_call_t *icall)
     604static void comp_window_get_event(window_t *win, ipc_call_t *icall)
    605605{
    606606        window_event_t *event = (window_event_t *) prodcons_consume(&win->queue);
    607607
    608         cap_call_handle_t chandle;
     608        ipc_call_t call;
    609609        size_t len;
    610610
    611         if (!async_data_read_receive(&chandle, &len)) {
    612                 async_answer_0(icall_handle, EINVAL);
     611        if (!async_data_read_receive(&call, &len)) {
     612                async_answer_0(icall, EINVAL);
    613613                free(event);
    614614                return;
    615615        }
    616616
    617         errno_t rc = async_data_read_finalize(chandle, event, len);
     617        errno_t rc = async_data_read_finalize(&call, event, len);
    618618        if (rc != EOK) {
    619                 async_answer_0(icall_handle, ENOMEM);
     619                async_answer_0(icall, ENOMEM);
    620620                free(event);
    621621                return;
    622622        }
    623623
    624         async_answer_0(icall_handle, EOK);
     624        async_answer_0(icall, EOK);
    625625        free(event);
    626626}
    627627
    628 static void comp_window_damage(window_t *win, cap_call_handle_t icall_handle, ipc_call_t *icall)
     628static void comp_window_damage(window_t *win, ipc_call_t *icall)
    629629{
    630630        double x = IPC_GET_ARG1(*icall);
    … …  
    644644        }
    645645
    646         async_answer_0(icall_handle, EOK);
    647 }
    648 
    649 static void comp_window_grab(window_t *win, cap_call_handle_t icall_handle, ipc_call_t *icall)
     646        async_answer_0(icall, EOK);
     647}
     648
     649static void comp_window_grab(window_t *win, ipc_call_t *icall)
    650650{
    651651        sysarg_t pos_id = IPC_GET_ARG1(*icall);
    … …  
    674674        }
    675675
    676         async_answer_0(icall_handle, EOK);
     676        async_answer_0(icall, EOK);
    677677}
    678678
    … …  
    706706}
    707707
    708 static void comp_window_resize(window_t *win, cap_call_handle_t icall_handle, ipc_call_t *icall)
    709 {
    710         cap_call_handle_t chandle;
     708static void comp_window_resize(window_t *win, ipc_call_t *icall)
     709{
     710        ipc_call_t call;
    711711        size_t size;
    712712        unsigned int flags;
    713713
    714714        /* Start sharing resized window with client. */
    715         if (!async_share_out_receive(&chandle, &size, &flags)) {
    716                 async_answer_0(icall_handle, EINVAL);
     715        if (!async_share_out_receive(&call, &size, &flags)) {
     716                async_answer_0(icall, EINVAL);
    717717                return;
    718718        }
    719719
    720720        void *new_cell_storage;
    721         errno_t rc = async_share_out_finalize(chandle, &new_cell_storage);
     721        errno_t rc = async_share_out_finalize(&call, &new_cell_storage);
    722722        if ((rc != EOK) || (new_cell_storage == AS_MAP_FAILED)) {
    723                 async_answer_0(icall_handle, ENOMEM);
     723                async_answer_0(icall, ENOMEM);
    724724                return;
    725725        }
    … …  
    730730        if (!new_surface) {
    731731                as_area_destroy(new_cell_storage);
    732                 async_answer_0(icall_handle, ENOMEM);
     732                async_answer_0(icall, ENOMEM);
    733733                return;
    734734        }
    … …  
    817817        comp_damage(x, y, width, height);
    818818
    819         async_answer_0(icall_handle, EOK);
     819        async_answer_0(icall, EOK);
    820820}
    821821
    … …  
    849849}
    850850
    851 static void comp_window_close(window_t *win, cap_call_handle_t icall_handle, ipc_call_t *icall)
     851static void comp_window_close(window_t *win, ipc_call_t *icall)
    852852{
    853853        /* Stop managing the window. */
    … …  
    891891
    892892        comp_damage(x, y, width, height);
    893         async_answer_0(icall_handle, EOK);
    894 }
    895 
    896 static void comp_window_close_request(window_t *win, cap_call_handle_t icall_handle, ipc_call_t *icall)
     893        async_answer_0(icall, EOK);
     894}
     895
     896static void comp_window_close_request(window_t *win, ipc_call_t *icall)
    897897{
    898898        window_event_t *event = (window_event_t *) malloc(sizeof(window_event_t));
    899899        if (event == NULL) {
    900                 async_answer_0(icall_handle, ENOMEM);
     900                async_answer_0(icall, ENOMEM);
    901901                return;
    902902        }
    … …  
    906906
    907907        prodcons_produce(&win->queue, &event->link);
    908         async_answer_0(icall_handle, EOK);
    909 }
    910 
    911 static void client_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     908        async_answer_0(icall, EOK);
     909}
     910
     911static void client_connection(ipc_call_t *icall, void *arg)
    912912{
    913913        ipc_call_t call;
    914         cap_call_handle_t chandle;
    915914        service_id_t service_id = (service_id_t) IPC_GET_ARG2(*icall);
    916915
    917916        /* Allocate resources for new window and register it to the location service. */
    918917        if (service_id == winreg_id) {
    919                 async_answer_0(icall_handle, EOK);
    920 
    921                 chandle = async_get_call(&call);
     918                async_answer_0(icall, EOK);
     919
     920                async_get_call(&call);
    922921                if (IPC_GET_IMETHOD(call) == WINDOW_REGISTER) {
    923922                        fibril_mutex_lock(&window_list_mtx);
    … …  
    925924                        window_t *win = window_create();
    926925                        if (!win) {
    927                                 async_answer_2(chandle, ENOMEM, 0, 0);
     926                                async_answer_2(&call, ENOMEM, 0, 0);
    928927                                fibril_mutex_unlock(&window_list_mtx);
    929928                                return;
    … …  
    944943                        if (loc_service_register(name_in, &win->in_dsid) != EOK) {
    945944                                window_destroy(win);
    946                                 async_answer_2(chandle, EINVAL, 0, 0);
     945                                async_answer_2(&call, EINVAL, 0, 0);
    947946                                fibril_mutex_unlock(&window_list_mtx);
    948947                                return;
    … …  
    952951                                loc_service_unregister(win->in_dsid);
    953952                                window_destroy(win);
    954                                 async_answer_2(chandle, EINVAL, 0, 0);
     953                                async_answer_2(&call, EINVAL, 0, 0);
    955954                                fibril_mutex_unlock(&window_list_mtx);
    956955                                return;
    … …  
    966965                        }
    967966
    968                         async_answer_2(chandle, EOK, win->in_dsid, win->out_dsid);
     967                        async_answer_2(&call, EOK, win->in_dsid, win->out_dsid);
    969968                        fibril_mutex_unlock(&window_list_mtx);
    970969
    … …  
    975974                        return;
    976975                } else {
    977                         async_answer_0(chandle, EINVAL);
     976                        async_answer_0(&call, EINVAL);
    978977                        return;
    979978                }
    … …  
    993992        if (win) {
    994993                atomic_inc(&win->ref_cnt);
    995                 async_answer_0(icall_handle, EOK);
     994                async_answer_0(icall, EOK);
    996995        } else {
    997                 async_answer_0(icall_handle, EINVAL);
     996                async_answer_0(icall, EINVAL);
    998997                return;
    999998        }
    … …  
    10021001        if (win->in_dsid == service_id) {
    10031002                while (true) {
    1004                         chandle = async_get_call(&call);
     1003                        async_get_call(&call);
    10051004
    10061005                        if (!IPC_GET_IMETHOD(call)) {
    1007                                 async_answer_0(chandle, EOK);
     1006                                async_answer_0(&call, EOK);
    10081007                                atomic_dec(&win->ref_cnt);
    10091008                                window_destroy(win);
    … …  
    10131012                        switch (IPC_GET_IMETHOD(call)) {
    10141013                        case WINDOW_GET_EVENT:
    1015                                 comp_window_get_event(win, chandle, &call);
     1014                                comp_window_get_event(win, &call);
    10161015                                break;
    10171016                        default:
    1018                                 async_answer_0(chandle, EINVAL);
     1017                                async_answer_0(&call, EINVAL);
    10191018                        }
    10201019                }
    10211020        } else if (win->out_dsid == service_id) {
    10221021                while (true) {
    1023                         chandle = async_get_call(&call);
     1022                        async_get_call(&call);
    10241023
    10251024                        if (!IPC_GET_IMETHOD(call)) {
    1026                                 comp_window_close(win, chandle, &call);
     1025                                comp_window_close(win, &call);
    10271026                                atomic_dec(&win->ref_cnt);
    10281027                                window_destroy(win);
    … …  
    10321031                        switch (IPC_GET_IMETHOD(call)) {
    10331032                        case WINDOW_DAMAGE:
    1034                                 comp_window_damage(win, chandle, &call);
     1033                                comp_window_damage(win, &call);
    10351034                                break;
    10361035                        case WINDOW_GRAB:
    1037                                 comp_window_grab(win, chandle, &call);
     1036                                comp_window_grab(win, &call);
    10381037                                break;
    10391038                        case WINDOW_RESIZE:
    1040                                 comp_window_resize(win, chandle, &call);
     1039                                comp_window_resize(win, &call);
    10411040                                break;
    10421041                        case WINDOW_CLOSE:
    … …  
    10451044                                 * the case when the client is killed abruptly.
    10461045                                 */
    1047                                 async_answer_0(chandle, EOK);
     1046                                async_answer_0(&call, EOK);
    10481047                                break;
    10491048                        case WINDOW_CLOSE_REQUEST:
    1050                                 comp_window_close_request(win, chandle, &call);
     1049                                comp_window_close_request(win, &call);
    10511050                                break;
    10521051                        default:
    1053                                 async_answer_0(chandle, EINVAL);
    1054                         }
    1055                 }
    1056         }
    1057 }
    1058 
    1059 static void comp_mode_change(viewport_t *vp, cap_call_handle_t icall_handle, ipc_call_t *icall)
     1052                                async_answer_0(&call, EINVAL);
     1053                        }
     1054                }
     1055        }
     1056}
     1057
     1058static void comp_mode_change(viewport_t *vp, ipc_call_t *icall)
    10601059{
    10611060        sysarg_t mode_idx = IPC_GET_ARG2(*icall);
    … …  
    10671066        if (rc != EOK) {
    10681067                fibril_mutex_unlock(&viewport_list_mtx);
    1069                 async_answer_0(icall_handle, EINVAL);
     1068                async_answer_0(icall, EINVAL);
    10701069                return;
    10711070        }
    … …  
    10761075        if (!new_surface) {
    10771076                fibril_mutex_unlock(&viewport_list_mtx);
    1078                 async_answer_0(icall_handle, ENOMEM);
     1077                async_answer_0(icall, ENOMEM);
    10791078                return;
    10801079        }
    … …  
    10861085                surface_destroy(new_surface);
    10871086                fibril_mutex_unlock(&viewport_list_mtx);
    1088                 async_answer_0(icall_handle, rc);
     1087                async_answer_0(icall, rc);
    10891088                return;
    10901089        }
    … …  
    10961095
    10971096        fibril_mutex_unlock(&viewport_list_mtx);
    1098         async_answer_0(icall_handle, EOK);
     1097        async_answer_0(icall, EOK);
    10991098
    11001099        comp_restrict_pointers();
    … …  
    11301129        fibril_mutex_unlock(&window_list_mtx);
    11311130
    1132         async_answer_0(icall_handle, EOK);
     1131        async_answer_0(icall, EOK);
    11331132
    11341133        /* All fibrils of the compositor will terminate soon. */
    … …  
    11361135#endif
    11371136
    1138 static void comp_visualizer_disconnect(viewport_t *vp, cap_call_handle_t icall_handle, ipc_call_t *icall)
     1137static void comp_visualizer_disconnect(viewport_t *vp, ipc_call_t *icall)
    11391138{
    11401139        /* Release viewport resources. */
    … …  
    11461145        fibril_mutex_unlock(&viewport_list_mtx);
    11471146
    1148         async_answer_0(icall_handle, EOK);
     1147        async_answer_0(icall, EOK);
    11491148
    11501149        comp_restrict_pointers();
    … …  
    11521151}
    11531152
    1154 static void vsl_notifications(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     1153static void vsl_notifications(ipc_call_t *icall, void *arg)
    11551154{
    11561155        viewport_t *vp = NULL;
    … …  
    11701169        while (true) {
    11711170                ipc_call_t call;
    1172                 cap_call_handle_t chandle = async_get_call(&call);
     1171                async_get_call(&call);
    11731172
    11741173                if (!IPC_GET_IMETHOD(call)) {
    … …  
    11791178                switch (IPC_GET_IMETHOD(call)) {
    11801179                case VISUALIZER_MODE_CHANGE:
    1181                         comp_mode_change(vp, chandle, &call);
     1180                        comp_mode_change(vp, &call);
    11821181                        break;
    11831182                case VISUALIZER_DISCONNECT:
    1184                         comp_visualizer_disconnect(vp, chandle, &call);
     1183                        comp_visualizer_disconnect(vp, &call);
    11851184                        return;
    11861185                default:
    1187                         async_answer_0(chandle, EINVAL);
     1186                        async_answer_0(&call, EINVAL);
    11881187                }
    11891188        }

  • uspace/srv/hid/compositor/compositor.h

    r76f566d r984a9ba  
    3737
    3838typedef native_t desktop_coord_t;
     39
    3940typedef struct {
    4041        desktop_coord_t x;
    4142        desktop_coord_t y;
    4243} desktop_point_t;
     44
    4345typedef desktop_point_t desktop_vector_t;
    4446
    … …  
    5557        double y;
    5658} double_point_t;
     59
    5760typedef double_point_t double_vector_t;
    5861

  • uspace/srv/hid/console/console.c

    r76f566d r984a9ba  
    507507}
    508508
    509 static void client_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     509static void client_connection(ipc_call_t *icall, void *arg)
    510510{
    511511        console_t *cons = NULL;
    … …  
    519519
    520520        if (cons == NULL) {
    521                 async_answer_0(icall_handle, ENOENT);
     521                async_answer_0(icall, ENOENT);
    522522                return;
    523523        }
    … …  
    526526                cons_set_cursor_vis(cons, true);
    527527
    528         con_conn(icall_handle, icall, &cons->srvs);
     528        con_conn(icall, &cons->srvs);
    529529}
    530530

  • uspace/srv/hid/input/ctl/kbdev.c

    r76f566d r984a9ba  
    5454static void kbdev_ctl_set_ind(kbd_dev_t *, unsigned int);
    5555
    56 static void kbdev_callback_conn(cap_call_handle_t, ipc_call_t *, void *arg);
     56static void kbdev_callback_conn(ipc_call_t *, void *arg);
    5757
    5858kbd_ctl_ops_t kbdev_ctl = {
    … …  
    147147}
    148148
    149 static void kbdev_callback_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     149static void kbdev_callback_conn(ipc_call_t *icall, void *arg)
    150150{
    151151        kbdev_t *kbdev;
    … …  
    158158        while (true) {
    159159                ipc_call_t call;
    160                 cap_call_handle_t chandle;
     160                async_get_call(&call);
    161161
    162                 chandle = async_get_call(&call);
    163162                if (!IPC_GET_IMETHOD(call)) {
    164163                        kbdev_destroy(kbdev);
    … …  
    179178                }
    180179
    181                 async_answer_0(chandle, retval);
     180                async_answer_0(&call, retval);
    182181        }
    183182}

  • uspace/srv/hid/input/input.c

    r76f566d r984a9ba  
    320320
    321321/** New client connection */
    322 static void client_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     322static void client_connection(ipc_call_t *icall, void *arg)
    323323{
    324324        client_t *client = (client_t *) async_get_client_data();
    325325        if (client == NULL) {
    326                 async_answer_0(icall_handle, ENOMEM);
     326                async_answer_0(icall, ENOMEM);
    327327                return;
    328328        }
    329329
    330         async_answer_0(icall_handle, EOK);
     330        async_answer_0(icall, EOK);
    331331
    332332        while (true) {
    333333                ipc_call_t call;
    334                 cap_call_handle_t chandle = async_get_call(&call);
     334                async_get_call(&call);
    335335
    336336                if (!IPC_GET_IMETHOD(call)) {
    … …  
    340340                        }
    341341
    342                         async_answer_0(chandle, EOK);
     342                        async_answer_0(&call, EOK);
    343343                        return;
    344344                }
    … …  
    349349                        if (client->sess == NULL) {
    350350                                client->sess = sess;
    351                                 async_answer_0(chandle, EOK);
     351                                async_answer_0(&call, EOK);
    352352                        } else
    353                                 async_answer_0(chandle, ELIMIT);
     353                                async_answer_0(&call, ELIMIT);
    354354                } else {
    355355                        switch (IPC_GET_IMETHOD(call)) {
    … …  
    357357                                active_client = client;
    358358                                client_arbitration();
    359                                 async_answer_0(chandle, EOK);
     359                                async_answer_0(&call, EOK);
    360360                                break;
    361361                        default:
    362                                 async_answer_0(chandle, EINVAL);
     362                                async_answer_0(&call, EINVAL);
    363363                        }
    364364                }

  • uspace/srv/hid/input/proto/mousedev.c

    r76f566d r984a9ba  
    7070}
    7171
    72 static void mousedev_callback_conn(cap_call_handle_t icall_handle, ipc_call_t *icall,
    73     void *arg)
     72static void mousedev_callback_conn(ipc_call_t *icall, void *arg)
    7473{
    7574        /* Mousedev device structure */
    … …  
    7877        while (true) {
    7978                ipc_call_t call;
    80                 cap_call_handle_t chandle = async_get_call(&call);
     79                async_get_call(&call);
    8180
    8281                if (!IPC_GET_IMETHOD(call)) {
    … …  
    110109                }
    111110
    112                 async_answer_0(chandle, retval);
     111                async_answer_0(&call, retval);
    113112        }
    114113}

  • uspace/srv/hid/isdv4_tablet/main.c

    r76f566d r984a9ba  
    6363}
    6464
    65 static void mouse_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    66 {
    67         async_answer_0(icall_handle, EOK);
     65static void mouse_connection(ipc_call_t *icall, void *arg)
     66{
     67        async_answer_0(icall, EOK);
    6868
    6969        async_sess_t *sess =
    … …  
    7979        while (true) {
    8080                ipc_call_t call;
    81                 cap_call_handle_t chandle = async_get_call(&call);
     81                async_get_call(&call);
    8282
    8383                if (!IPC_GET_IMETHOD(call))
    8484                        break;
    8585
    86                 async_answer_0(chandle, ENOTSUP);
     86                async_answer_0(&call, ENOTSUP);
    8787        }
    8888}

  • uspace/srv/hid/output/output.c

    r76f566d r984a9ba  
    7878}
    7979
    80 static void srv_yield(cap_call_handle_t icall_handle, ipc_call_t *icall)
     80static void srv_yield(ipc_call_t *icall)
    8181{
    8282        errno_t ret = EOK;
    … …  
    9090        }
    9191
    92         async_answer_0(icall_handle, ret);
    93 }
    94 
    95 static void srv_claim(cap_call_handle_t icall_handle, ipc_call_t *icall)
     92        async_answer_0(icall, ret);
     93}
     94
     95static void srv_claim(ipc_call_t *icall)
    9696{
    9797        errno_t ret = EOK;
    … …  
    105105        }
    106106
    107         async_answer_0(icall_handle, ret);
    108 }
    109 
    110 static void srv_get_dimensions(cap_call_handle_t icall_handle, ipc_call_t *icall)
     107        async_answer_0(icall, ret);
     108}
     109
     110static void srv_get_dimensions(ipc_call_t *icall)
    111111{
    112112        sysarg_t cols = MAX_COLS;
    … …  
    118118        }
    119119
    120         async_answer_2(icall_handle, EOK, cols, rows);
    121 }
    122 
    123 static void srv_get_caps(cap_call_handle_t icall_handle, ipc_call_t *icall)
     120        async_answer_2(icall, EOK, cols, rows);
     121}
     122
     123static void srv_get_caps(ipc_call_t *icall)
    124124{
    125125        console_caps_t caps = 0;
    … …  
    131131        }
    132132
    133         async_answer_1(icall_handle, EOK, caps);
    134 }
    135 
    136 static frontbuf_t *resolve_frontbuf(sysarg_t handle, cap_call_handle_t icall_handle)
     133        async_answer_1(icall, EOK, caps);
     134}
     135
     136static frontbuf_t *resolve_frontbuf(sysarg_t handle, ipc_call_t *icall)
    137137{
    138138        frontbuf_t *frontbuf = NULL;
    … …  
    145145
    146146        if (frontbuf == NULL) {
    147                 async_answer_0(icall_handle, ENOENT);
     147                async_answer_0(icall, ENOENT);
    148148                return NULL;
    149149        }
    … …  
    152152}
    153153
    154 static void srv_frontbuf_create(cap_call_handle_t icall_handle, ipc_call_t *icall)
     154static void srv_frontbuf_create(ipc_call_t *icall)
    155155{
    156156        frontbuf_t *frontbuf = (frontbuf_t *) malloc(sizeof(frontbuf_t));
    157157        if (frontbuf == NULL) {
    158                 async_answer_0(icall_handle, ENOMEM);
     158                async_answer_0(icall, ENOMEM);
    159159                return;
    160160        }
    … …  
    162162        link_initialize(&frontbuf->link);
    163163
    164         cap_call_handle_t chandle;
    165         if (!async_share_out_receive(&chandle, &frontbuf->size,
     164        ipc_call_t call;
     165        if (!async_share_out_receive(&call, &frontbuf->size,
    166166            &frontbuf->flags)) {
    167167                free(frontbuf);
    168                 async_answer_0(icall_handle, EINVAL);
    169                 return;
    170         }
    171 
    172         errno_t rc = async_share_out_finalize(chandle, &frontbuf->data);
     168                async_answer_0(icall, EINVAL);
     169                return;
     170        }
     171
     172        errno_t rc = async_share_out_finalize(&call, &frontbuf->data);
    173173        if ((rc != EOK) || (frontbuf->data == AS_MAP_FAILED)) {
    174174                free(frontbuf);
    175                 async_answer_0(icall_handle, ENOMEM);
     175                async_answer_0(icall, ENOMEM);
    176176                return;
    177177        }
    178178
    179179        list_append(&frontbuf->link, &frontbufs);
    180         async_answer_1(icall_handle, EOK, (sysarg_t) frontbuf);
    181 }
    182 
    183 static void srv_frontbuf_destroy(cap_call_handle_t icall_handle, ipc_call_t *icall)
    184 {
    185         frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), icall_handle);
     180        async_answer_1(icall, EOK, (sysarg_t) frontbuf);
     181}
     182
     183static void srv_frontbuf_destroy(ipc_call_t *icall)
     184{
     185        frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), icall);
    186186        if (frontbuf == NULL)
    187187                return;
    … …  
    191191        free(frontbuf);
    192192
    193         async_answer_0(icall_handle, EOK);
    194 }
    195 
    196 static void srv_cursor_update(cap_call_handle_t icall_handle, ipc_call_t *icall)
    197 {
    198         frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), icall_handle);
     193        async_answer_0(icall, EOK);
     194}
     195
     196static void srv_cursor_update(ipc_call_t *icall)
     197{
     198        frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), icall);
    199199        if (frontbuf == NULL)
    200200                return;
    … …  
    223223        }
    224224
    225         async_answer_0(icall_handle, EOK);
    226 }
    227 
    228 static void srv_set_style(cap_call_handle_t icall_handle, ipc_call_t *icall)
     225        async_answer_0(icall, EOK);
     226}
     227
     228static void srv_set_style(ipc_call_t *icall)
    229229{
    230230        list_foreach(outdevs, link, outdev_t, dev) {
    … …  
    234234        }
    235235
    236         async_answer_0(icall_handle, EOK);
    237 }
    238 
    239 static void srv_set_color(cap_call_handle_t icall_handle, ipc_call_t *icall)
     236        async_answer_0(icall, EOK);
     237}
     238
     239static void srv_set_color(ipc_call_t *icall)
    240240{
    241241        list_foreach(outdevs, link, outdev_t, dev) {
    … …  
    249249        }
    250250
    251         async_answer_0(icall_handle, EOK);
    252 }
    253 
    254 static void srv_set_rgb_color(cap_call_handle_t icall_handle, ipc_call_t *icall)
     251        async_answer_0(icall, EOK);
     252}
     253
     254static void srv_set_rgb_color(ipc_call_t *icall)
    255255{
    256256        list_foreach(outdevs, link, outdev_t, dev) {
    … …  
    260260        }
    261261
    262         async_answer_0(icall_handle, EOK);
     262        async_answer_0(icall, EOK);
    263263}
    264264
    … …  
    302302}
    303303
    304 static void srv_update(cap_call_handle_t icall_handle, ipc_call_t *icall)
    305 {
    306         frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), icall_handle);
     304static void srv_update(ipc_call_t *icall)
     305{
     306        frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), icall);
    307307        if (frontbuf == NULL)
    308308                return;
    … …  
    348348        }
    349349
    350 
    351         async_answer_0(icall_handle, EOK);
    352 }
    353 
    354 static void srv_damage(cap_call_handle_t icall_handle, ipc_call_t *icall)
    355 {
    356         frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), icall_handle);
     350        async_answer_0(icall, EOK);
     351}
     352
     353static void srv_damage(ipc_call_t *icall)
     354{
     355        frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), icall);
    357356        if (frontbuf == NULL)
    358357                return;
    … …  
    388387
    389388        }
    390         async_answer_0(icall_handle, EOK);
    391 }
    392 
    393 static void client_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     389
     390        async_answer_0(icall, EOK);
     391}
     392
     393static void client_connection(ipc_call_t *icall, void *arg)
    394394{
    395395        /* Accept the connection */
    396         async_answer_0(icall_handle, EOK);
     396        async_answer_0(icall, EOK);
    397397
    398398        while (true) {
    399399                ipc_call_t call;
    400                 cap_call_handle_t chandle = async_get_call(&call);
     400                async_get_call(&call);
    401401
    402402                if (!IPC_GET_IMETHOD(call)) {
    403                         async_answer_0(chandle, EOK);
     403                        async_answer_0(&call, EOK);
    404404                        break;
    405405                }
    … …  
    407407                switch (IPC_GET_IMETHOD(call)) {
    408408                case OUTPUT_YIELD:
    409                         srv_yield(chandle, &call);
     409                        srv_yield(&call);
    410410                        break;
    411411                case OUTPUT_CLAIM:
    412                         srv_claim(chandle, &call);
     412                        srv_claim(&call);
    413413                        break;
    414414                case OUTPUT_GET_DIMENSIONS:
    415                         srv_get_dimensions(chandle, &call);
     415                        srv_get_dimensions(&call);
    416416                        break;
    417417                case OUTPUT_GET_CAPS:
    418                         srv_get_caps(chandle, &call);
     418                        srv_get_caps(&call);
    419419                        break;
    420420
    421421                case OUTPUT_FRONTBUF_CREATE:
    422                         srv_frontbuf_create(chandle, &call);
     422                        srv_frontbuf_create(&call);
    423423                        break;
    424424                case OUTPUT_FRONTBUF_DESTROY:
    425                         srv_frontbuf_destroy(chandle, &call);
     425                        srv_frontbuf_destroy(&call);
    426426                        break;
    427427
    428428                case OUTPUT_CURSOR_UPDATE:
    429                         srv_cursor_update(chandle, &call);
     429                        srv_cursor_update(&call);
    430430                        break;
    431431                case OUTPUT_SET_STYLE:
    432                         srv_set_style(chandle, &call);
     432                        srv_set_style(&call);
    433433                        break;
    434434                case OUTPUT_SET_COLOR:
    435                         srv_set_color(chandle, &call);
     435                        srv_set_color(&call);
    436436                        break;
    437437                case OUTPUT_SET_RGB_COLOR:
    438                         srv_set_rgb_color(chandle, &call);
     438                        srv_set_rgb_color(&call);
    439439                        break;
    440440                case OUTPUT_UPDATE:
    441                         srv_update(chandle, &call);
     441                        srv_update(&call);
    442442                        break;
    443443                case OUTPUT_DAMAGE:
    444                         srv_damage(chandle, &call);
     444                        srv_damage(&call);
    445445                        break;
    446446
    447447                default:
    448                         async_answer_0(chandle, EINVAL);
     448                        async_answer_0(&call, EINVAL);
    449449                }
    450450        }

  • uspace/srv/hid/remcons/remcons.c

    r76f566d r984a9ba  
    216216
    217217/** Callback when client connects to a telnet terminal. */
    218 static void client_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     218static void client_connection(ipc_call_t *icall, void *arg)
    219219{
    220220        /* Find the user. */
    221221        telnet_user_t *user = telnet_user_get_for_client_connection(IPC_GET_ARG2(*icall));
    222222        if (user == NULL) {
    223                 async_answer_0(icall_handle, ENOENT);
     223                async_answer_0(icall, ENOENT);
    224224                return;
    225225        }
    226226
    227227        /* Handle messages. */
    228         con_conn(icall_handle, icall, &user->srvs);
     228        con_conn(icall, &user->srvs);
    229229}
    230230

  • uspace/srv/hid/rfb/main.c

    r76f566d r984a9ba  
    145145}
    146146
    147 static void client_connection(cap_call_handle_t chandle, ipc_call_t *call, void *data)
    148 {
    149         graph_visualizer_connection(vis, chandle, call, data);
     147static void client_connection(ipc_call_t *call, void *data)
     148{
     149        graph_visualizer_connection(vis, call, data);
    150150}
    151151

  • uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c

    r76f566d r984a9ba  
    6969static s3c24xx_ts_t *ts;
    7070
    71 static void s3c24xx_ts_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
    72     void *arg);
    73 static void s3c24xx_ts_irq_handler(ipc_call_t *call, void *);
    74 static void s3c24xx_ts_pen_down(s3c24xx_ts_t *ts);
    75 static void s3c24xx_ts_pen_up(s3c24xx_ts_t *ts);
    76 static void s3c24xx_ts_eoc(s3c24xx_ts_t *ts);
    77 static int s3c24xx_ts_init(s3c24xx_ts_t *ts);
    78 static void s3c24xx_ts_wait_for_int_mode(s3c24xx_ts_t *ts, ts_updn_t updn);
    79 static void s3c24xx_ts_convert_samples(int smp0, int smp1, int *x, int *y);
    80 static int lin_map_range(int v, int i0, int i1, int o0, int o1);
     71static void s3c24xx_ts_connection(ipc_call_t *, void *);
     72static void s3c24xx_ts_irq_handler(ipc_call_t *, void *);
     73static void s3c24xx_ts_pen_down(s3c24xx_ts_t *);
     74static void s3c24xx_ts_pen_up(s3c24xx_ts_t *);
     75static void s3c24xx_ts_eoc(s3c24xx_ts_t *);
     76static int s3c24xx_ts_init(s3c24xx_ts_t *);
     77static void s3c24xx_ts_wait_for_int_mode(s3c24xx_ts_t *, ts_updn_t);
     78static void s3c24xx_ts_convert_samples(int, int, int *, int *);
     79static int lin_map_range(int, int, int, int, int);
    8180
    8281int main(int argc, char *argv[])
    … …  
    371370
    372371/** Handle mouse client connection. */
    373 static void s3c24xx_ts_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
    374     void *arg)
    375 {
    376         async_answer_0(icall_handle, EOK);
     372static void s3c24xx_ts_connection(ipc_call_t *icall, void *arg)
     373{
     374        async_answer_0(icall, EOK);
    377375
    378376        while (true) {
    379377                ipc_call_t call;
    380                 cap_call_handle_t chandle = async_get_call(&call);
     378                async_get_call(&call);
    381379
    382380                if (!IPC_GET_IMETHOD(call)) {
    … …  
    386384                        }
    387385
    388                         async_answer_0(chandle, EOK);
     386                        async_answer_0(&call, EOK);
    389387                        return;
    390388                }
    … …  
    395393                        if (ts->client_sess == NULL) {
    396394                                ts->client_sess = sess;
    397                                 async_answer_0(chandle, EOK);
     395                                async_answer_0(&call, EOK);
    398396                        } else
    399                                 async_answer_0(chandle, ELIMIT);
     397                                async_answer_0(&call, ELIMIT);
    400398                } else
    401                         async_answer_0(chandle, EINVAL);
     399                        async_answer_0(&call, EINVAL);
    402400        }
    403401}
Note: See TracChangeset for help on using the changeset viewer.