Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset df2e621c in mainline


Ignore:
Timestamp:
2014-07-08T15:09:29Z (6 years ago)
Author:
Martin Decky <martin@…>
Branches:
master
Children:
53f68fd
Parents:
6bcecc2
Message:

fix wrong server-side IPC protocol implementation (thx Wolf Ramovsky for reporting)
cstyle fixes
code simplification

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/graph/graph.c

    r6bcecc2 rdf2e621c  
    5858visualizer_t *graph_alloc_visualizer(void)
    5959{
    60         visualizer_t *vs = (visualizer_t *) malloc(sizeof(visualizer_t));
    61         if (vs == NULL) {
    62                 return NULL;
    63         }
    64        
    65         return vs;
     60        return ((visualizer_t *) malloc(sizeof(visualizer_t)));
    6661}
    6762
     
    6964{
    7065        // TODO
    71         renderer_t *rnd = (renderer_t *) malloc(sizeof(renderer_t));
    72         if (rnd == NULL) {
    73                 return NULL;
    74         }
    75 
    76         return rnd;
     66        return ((renderer_t *) malloc(sizeof(renderer_t)));
    7767}
    7868
     
    9888int graph_register_visualizer(visualizer_t *vs)
    9989{
    100         int rc = EOK;
    101        
    10290        char node[LOC_NAME_MAXLEN + 1];
    10391        snprintf(node, LOC_NAME_MAXLEN, "%s%zu/%s%zu", NAMESPACE,
    10492            namespace_idx, VISUALIZER_NAME, visualizer_idx++);
    105 
     93       
    10694        category_id_t cat;
    107         rc = loc_category_get_id("visualizer", &cat, 0);
    108         if (rc != EOK) {
     95        int rc = loc_category_get_id("visualizer", &cat, 0);
     96        if (rc != EOK)
    10997                return rc;
    110         }
    111 
     98       
    11299        rc = loc_service_register(node, &vs->reg_svc_handle);
    113         if (rc != EOK) {
     100        if (rc != EOK)
    114101                return rc;
    115         }
    116 
     102       
    117103        rc = loc_service_add_to_cat(vs->reg_svc_handle, cat);
    118104        if (rc != EOK) {
     
    120106                return rc;
    121107        }
    122 
     108       
    123109        fibril_mutex_lock(&visualizer_list_mtx);
    124110        list_append(&vs->link, &visualizer_list);
    125111        fibril_mutex_unlock(&visualizer_list_mtx);
    126 
     112       
    127113        return rc;
    128114}
     
    130116int graph_register_renderer(renderer_t *rnd)
    131117{
    132         int rc = EOK;
    133 
    134118        char node[LOC_NAME_MAXLEN + 1];
    135119        snprintf(node, LOC_NAME_MAXLEN, "%s%zu/%s%zu", NAMESPACE,
    136120            namespace_idx, RENDERER_NAME, renderer_idx++);
    137 
     121       
    138122        category_id_t cat;
    139         rc = loc_category_get_id("renderer", &cat, 0);
    140         if (rc != EOK) {
     123        int rc = loc_category_get_id("renderer", &cat, 0);
     124        if (rc != EOK)
    141125                return rc;
    142         }
    143 
     126       
    144127        rc = loc_service_register(node, &rnd->reg_svc_handle);
    145         if (rc != EOK) {
     128        if (rc != EOK)
    146129                return rc;
    147         }
    148 
     130       
    149131        rc = loc_service_add_to_cat(rnd->reg_svc_handle, cat);
    150132        if (rc != EOK) {
     
    152134                return rc;
    153135        }
    154 
     136       
    155137        fibril_mutex_lock(&renderer_list_mtx);
    156138        list_append(&rnd->link, &renderer_list);
    157139        fibril_mutex_unlock(&renderer_list_mtx);
    158 
     140       
    159141        return rc;
    160142}
     
    163145{
    164146        visualizer_t *vs = NULL;
    165 
     147       
    166148        fibril_mutex_lock(&visualizer_list_mtx);
     149       
    167150        list_foreach(visualizer_list, link, visualizer_t, vcur) {
    168151                if (vcur->reg_svc_handle == handle) {
     
    171154                }
    172155        }
     156       
    173157        fibril_mutex_unlock(&visualizer_list_mtx);
    174 
     158       
    175159        return vs;
    176160}
     
    179163{
    180164        renderer_t *rnd = NULL;
    181 
     165       
    182166        fibril_mutex_lock(&renderer_list_mtx);
     167       
    183168        list_foreach(renderer_list, link, renderer_t, rcur) {
    184169                if (rcur->reg_svc_handle == handle) {
     
    187172                }
    188173        }
     174       
    189175        fibril_mutex_unlock(&renderer_list_mtx);
    190 
     176       
    191177        return rnd;
    192178}
     
    194180int graph_unregister_visualizer(visualizer_t *vs)
    195181{
    196         int rc = EOK;
    197 
    198182        fibril_mutex_lock(&visualizer_list_mtx);
    199         rc = loc_service_unregister(vs->reg_svc_handle);
     183        int rc = loc_service_unregister(vs->reg_svc_handle);
    200184        list_remove(&vs->link);
    201185        fibril_mutex_unlock(&visualizer_list_mtx);
    202 
     186       
    203187        return rc;
    204188}
     
    206190int graph_unregister_renderer(renderer_t *rnd)
    207191{
    208         int rc = EOK;
    209 
    210192        fibril_mutex_lock(&renderer_list_mtx);
    211         rc = loc_service_unregister(rnd->reg_svc_handle);
     193        int rc = loc_service_unregister(rnd->reg_svc_handle);
    212194        list_remove(&rnd->link);
    213195        fibril_mutex_unlock(&renderer_list_mtx);
    214 
     196       
    215197        return rc;
    216198}
     
    225207        assert(vs->cells.data == NULL);
    226208        assert(vs->dev_ctx == NULL);
    227 
     209       
    228210        free(vs);
    229211}
     
    233215        // TODO
    234216        assert(atomic_get(&rnd->ref_cnt) == 0);
    235 
     217       
    236218        free(rnd);
    237219}
     
    242224        int ret = async_req_2_0(exch, VISUALIZER_MODE_CHANGE, handle, mode_idx);
    243225        async_exchange_end(exch);
    244 
     226       
    245227        return ret;
    246228}
     
    251233        int ret = async_req_1_0(exch, VISUALIZER_DISCONNECT, handle);
    252234        async_exchange_end(exch);
    253 
     235       
    254236        async_hangup(sess);
    255 
     237       
    256238        return ret;
    257239}
     
    273255                }
    274256        }
    275 
     257       
    276258        /* Driver might also deallocate resources for the current mode. */
    277259        int rc = vs->ops.yield(vs);
    278 
     260       
    279261        /* Now that the driver was given a chance to deallocate resources,
    280262         * current mode can be unset. */
    281         if (vs->mode_set) {
     263        if (vs->mode_set)
    282264                vs->mode_set = false;
    283         }
    284 
     265       
    285266        async_answer_0(iid, rc);
    286267}
     
    288269static void vs_enumerate_modes(visualizer_t *vs, ipc_callid_t iid, ipc_call_t *icall)
    289270{
     271        ipc_callid_t callid;
     272        size_t len;
     273       
     274        if (!async_data_read_receive(&callid, &len)) {
     275                async_answer_0(callid, EREFUSED);
     276                async_answer_0(iid, EREFUSED);
     277                return;
     278        }
     279       
    290280        fibril_mutex_lock(&vs->mode_mtx);
    291281        link_t *link = list_nth(&vs->modes, IPC_GET_ARG1(*icall));
    292 
     282       
    293283        if (link != NULL) {
    294284                vslmode_list_element_t *mode_elem =
    295285                    list_get_instance(link, vslmode_list_element_t, link);
    296                 vslmode_t mode = mode_elem->mode;
    297                 fibril_mutex_unlock(&vs->mode_mtx);
    298 
    299                 ipc_callid_t callid;
    300                 size_t len;
    301 
    302                 if (!async_data_read_receive(&callid, &len)) {
    303                         async_answer_0(iid, EINVAL);
    304                         return;
    305                 }
    306                 int rc = async_data_read_finalize(callid, &mode, len);
    307                 if (rc != EOK) {
    308                         async_answer_0(iid, ENOMEM);
    309                         return;
    310                 }
    311 
    312                 async_answer_0(iid, EOK);
     286               
     287                int rc = async_data_read_finalize(callid, &mode_elem->mode, len);
     288                async_answer_0(iid, rc);
    313289        } else {
    314                 fibril_mutex_unlock(&vs->mode_mtx);
     290                async_answer_0(callid, ENOENT);
    315291                async_answer_0(iid, ENOENT);
    316292        }
     293       
     294        fibril_mutex_unlock(&vs->mode_mtx);
    317295}
    318296
    319297static void vs_get_default_mode(visualizer_t *vs, ipc_callid_t iid, ipc_call_t *icall)
    320298{
     299        ipc_callid_t callid;
     300        size_t len;
     301       
     302        if (!async_data_read_receive(&callid, &len)) {
     303                async_answer_0(callid, EREFUSED);
     304                async_answer_0(iid, EREFUSED);
     305                return;
     306        }
     307       
    321308        fibril_mutex_lock(&vs->mode_mtx);
    322309        vslmode_list_element_t *mode_elem = NULL;
     310       
    323311        list_foreach(vs->modes, link, vslmode_list_element_t, cur) {
    324312                if (cur->mode.index == vs->def_mode_idx) {
     
    327315                }
    328316        }
    329 
    330         vslmode_t mode;
     317       
    331318        if (mode_elem != NULL) {
    332                 mode = mode_elem->mode;
    333                 fibril_mutex_unlock(&vs->mode_mtx);
    334 
    335                 ipc_callid_t callid;
    336                 size_t len;
    337 
    338                 if (!async_data_read_receive(&callid, &len)) {
    339                         async_answer_0(iid, EINVAL);
    340                         return;
    341                 }
    342                 int rc = async_data_read_finalize(callid, &mode, len);
    343                 if (rc != EOK) {
    344                         async_answer_0(iid, ENOMEM);
    345                         return;
    346                 }
    347                 async_answer_0(iid, EOK);
     319                int rc = async_data_read_finalize(callid, &mode_elem->mode, len);
     320                async_answer_0(iid, rc);
    348321        } else {
    349322                fibril_mutex_unlock(&vs->mode_mtx);
     323                async_answer_0(callid, ENOENT);
    350324                async_answer_0(iid, ENOENT);
    351325        }
     326       
     327        fibril_mutex_unlock(&vs->mode_mtx);
    352328}
    353329
    354330static void vs_get_current_mode(visualizer_t *vs, ipc_callid_t iid, ipc_call_t *icall)
    355331{
     332        ipc_callid_t callid;
     333        size_t len;
     334       
     335        if (!async_data_read_receive(&callid, &len)) {
     336                async_answer_0(callid, EREFUSED);
     337                async_answer_0(iid, EREFUSED);
     338                return;
     339        }
     340       
    356341        if (vs->mode_set) {
    357                 ipc_callid_t callid;
    358                 size_t len;
    359 
    360                 if (!async_data_read_receive(&callid, &len)) {
    361                         async_answer_0(iid, EINVAL);
    362                         return;
    363                 }
    364342                int rc = async_data_read_finalize(callid, &vs->cur_mode, len);
    365                 if (rc != EOK) {
    366                         async_answer_0(iid, ENOMEM);
    367                         return;
    368                 }
    369 
    370                 async_answer_0(iid, EOK);
     343                async_answer_0(iid, rc);
    371344        } else {
     345                async_answer_0(callid, ENOENT);
    372346                async_answer_0(iid, ENOENT);
    373347        }
     
    376350static void vs_get_mode(visualizer_t *vs, ipc_callid_t iid, ipc_call_t *icall)
    377351{
     352        ipc_callid_t callid;
     353        size_t len;
     354       
     355        if (!async_data_read_receive(&callid, &len)) {
     356                async_answer_0(callid, EREFUSED);
     357                async_answer_0(iid, EREFUSED);
     358                return;
     359        }
     360       
    378361        sysarg_t mode_idx = IPC_GET_ARG1(*icall);
    379 
     362       
    380363        fibril_mutex_lock(&vs->mode_mtx);
    381364        vslmode_list_element_t *mode_elem = NULL;
     365       
    382366        list_foreach(vs->modes, link, vslmode_list_element_t, cur) {
    383367                if (cur->mode.index == mode_idx) {
     
    386370                }
    387371        }
    388 
    389         vslmode_t mode;
     372       
    390373        if (mode_elem != NULL) {
    391                 mode = mode_elem->mode;
    392                 fibril_mutex_unlock(&vs->mode_mtx);
    393 
    394                 ipc_callid_t callid;
    395                 size_t len;
    396 
    397                 if (!async_data_read_receive(&callid, &len)) {
    398                         async_answer_0(iid, EINVAL);
    399                         return;
    400                 }
    401                 int rc = async_data_read_finalize(callid, &mode, len);
    402                 if (rc != EOK) {
    403                         async_answer_0(iid, ENOMEM);
    404                         return;
    405                 }
    406                 async_answer_0(iid, EOK);
     374                int rc = async_data_read_finalize(callid, &mode_elem->mode, len);
     375                async_answer_0(iid, rc);
    407376        } else {
    408                 fibril_mutex_unlock(&vs->mode_mtx);
     377                async_answer_0(callid, ENOENT);
    409378                async_answer_0(iid, ENOENT);
    410379        }
     380       
     381        fibril_mutex_unlock(&vs->mode_mtx);
    411382}
    412383
    413384static void vs_set_mode(visualizer_t *vs, ipc_callid_t iid, ipc_call_t *icall)
    414385{
    415         int rc = EOK;
    416 
     386        ipc_callid_t callid;
     387        size_t size;
     388        unsigned int flags;
     389       
     390        /* Retrieve the shared cell storage for the new mode. */
     391        if (!async_share_out_receive(&callid, &size, &flags)) {
     392                async_answer_0(callid, EREFUSED);
     393                async_answer_0(iid, EREFUSED);
     394                return;
     395        }
     396       
    417397        /* Retrieve mode index and version. */
    418398        sysarg_t mode_idx = IPC_GET_ARG1(*icall);
    419399        sysarg_t mode_version = IPC_GET_ARG2(*icall);
    420 
     400       
    421401        /* Find mode in the list. */
    422402        fibril_mutex_lock(&vs->mode_mtx);
    423403        vslmode_list_element_t *mode_elem = NULL;
     404       
    424405        list_foreach(vs->modes, link, vslmode_list_element_t, cur) {
    425406                if (cur->mode.index == mode_idx) {
     
    428409                }
    429410        }
    430 
     411       
     412        if (mode_elem == NULL) {
     413                fibril_mutex_unlock(&vs->mode_mtx);
     414                async_answer_0(callid, ENOENT);
     415                async_answer_0(iid, ENOENT);
     416                return;
     417        }
     418       
    431419        /* Extract mode description from the list node. */
    432         vslmode_t new_mode;
    433         if (mode_elem != NULL) {
    434                 new_mode = mode_elem->mode;
    435                 fibril_mutex_unlock(&vs->mode_mtx);
    436         } else {
    437                 fibril_mutex_unlock(&vs->mode_mtx);
    438                 async_answer_0(iid, ENOENT);
    439                 return;
    440         }
    441 
     420        vslmode_t new_mode = mode_elem->mode;
     421        fibril_mutex_unlock(&vs->mode_mtx);
     422       
    442423        /* Check whether the mode is still up-to-date. */
    443424        if (new_mode.version != mode_version) {
     425                async_answer_0(callid, EINVAL);
    444426                async_answer_0(iid, EINVAL);
    445427                return;
    446428        }
    447 
    448         ipc_callid_t callid;
    449         size_t size;
    450         unsigned int flags;
    451 
    452         /* Retrieve the shared cell storage for the new mode. */
    453         if (!async_share_out_receive(&callid, &size, &flags)) {
    454                 async_answer_0(iid, EINVAL);
    455                 return;
    456         }
     429       
    457430        void *new_cell_storage;
    458         rc = async_share_out_finalize(callid, &new_cell_storage);
     431        int rc = async_share_out_finalize(callid, &new_cell_storage);
    459432        if ((rc != EOK) || (new_cell_storage == AS_MAP_FAILED)) {
    460433                async_answer_0(iid, ENOMEM);
    461434                return;
    462435        }
    463 
     436       
    464437        /* Change device internal state. */
    465438        rc = vs->ops.change_mode(vs, new_mode);
    466 
     439       
    467440        /* Device driver could not establish new mode. Rollback. */
    468441        if (rc != EOK) {
     
    471444                return;
    472445        }
    473 
    474         /* Because resources for the new mode were successfully claimed,
    475          * it is finally possible to free resources allocated for the old mode. */
     446       
     447        /*
     448         * Because resources for the new mode were successfully
     449         * claimed, it is finally possible to free resources
     450         * allocated for the old mode.
     451         */
    476452        if (vs->mode_set) {
    477453                if (vs->cells.data != NULL) {
     
    480456                }
    481457        }
    482 
     458       
    483459        /* Insert new mode into the visualizer. */
    484460        vs->cells.width = new_mode.screen_width;
     
    487463        vs->cur_mode = new_mode;
    488464        vs->mode_set = true;
    489 
     465       
    490466        async_answer_0(iid, EOK);
    491467}
     
    500476        sysarg_t y_offset = (IPC_GET_ARG5(*icall) & 0xffffffff);
    501477#endif
    502 
     478       
    503479        int rc = vs->ops.handle_damage(vs,
    504480            IPC_GET_ARG1(*icall), IPC_GET_ARG2(*icall),
    505481            IPC_GET_ARG3(*icall), IPC_GET_ARG4(*icall),
    506                 x_offset, y_offset);
     482            x_offset, y_offset);
    507483        async_answer_0(iid, rc);
    508484}
     
    525501        ipc_call_t call;
    526502        ipc_callid_t callid;
    527 
     503       
    528504        /* Claim the visualizer. */
    529505        if (!cas(&vs->ref_cnt, 0, 1)) {
     
    531507                return;
    532508        }
    533 
     509       
    534510        /* Accept the connection. */
    535511        async_answer_0(iid, EOK);
    536 
     512       
    537513        /* Establish callback session. */
    538514        callid = async_get_call(&call);
    539515        vs->notif_sess = async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
    540         if (vs->notif_sess != NULL) {
     516        if (vs->notif_sess != NULL)
    541517                async_answer_0(callid, EOK);
    542         } else {
     518        else
    543519                async_answer_0(callid, ELIMIT);
    544         }
    545 
     520       
    546521        /* Enter command loop. */
    547522        while (true) {
    548523                callid = async_get_call(&call);
    549 
     524               
    550525                if (!IPC_GET_IMETHOD(call)) {
    551526                        async_answer_0(callid, EINVAL);
    552527                        break;
    553528                }
    554 
     529               
    555530                switch (IPC_GET_IMETHOD(call)) {
    556531                case VISUALIZER_CLAIM:
     
    589564                }
    590565        }
    591 
     566       
    592567terminate:
    593568        async_hangup(vs->notif_sess);
     
    600575{
    601576        // TODO
    602 
     577       
    603578        ipc_call_t call;
    604579        ipc_callid_t callid;
    605 
     580       
    606581        /* Accept the connection. */
    607582        atomic_inc(&rnd->ref_cnt);
    608583        async_answer_0(iid, EOK);
    609 
     584       
    610585        /* Enter command loop. */
    611586        while (true) {
    612587                callid = async_get_call(&call);
    613 
     588               
    614589                if (!IPC_GET_IMETHOD(call)) {
    615590                        async_answer_0(callid, EINVAL);
    616591                        break;
    617592                }
    618 
     593               
    619594                switch (IPC_GET_IMETHOD(call)) {
    620595                default:
     
    623598                }
    624599        }
    625 
     600       
    626601terminate:
    627602        atomic_dec(&rnd->ref_cnt);
     
    633608        visualizer_t *vs = graph_get_visualizer(IPC_GET_ARG1(*icall));
    634609        renderer_t *rnd = graph_get_renderer(IPC_GET_ARG1(*icall));
    635 
    636         if (vs != NULL) {
     610       
     611        if (vs != NULL)
    637612                graph_visualizer_connection(vs, iid, icall, arg);
    638         } else if (rnd != NULL) {
     613        else if (rnd != NULL)
    639614                graph_renderer_connection(rnd, iid, icall, arg);
    640         } else {
     615        else
    641616                async_answer_0(iid, ENOENT);
    642         }
    643617}
    644618
Note: See TracChangeset for help on using the changeset viewer.