Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/loc.c

    ra35b458 r5a6cc679  
    6060                ipc_call_t call;
    6161                ipc_callid_t callid = async_get_call(&call);
    62 
     62               
    6363                if (!IPC_GET_IMETHOD(call)) {
    6464                        /* TODO: Handle hangup */
    6565                        return;
    6666                }
    67 
     67               
    6868                switch (IPC_GET_IMETHOD(call)) {
    6969                case LOC_EVENT_CAT_CHANGE:
    … …  
    7171                        loc_cat_change_cb_t cb_fun = cat_change_cb;
    7272                        fibril_mutex_unlock(&loc_callback_mutex);
    73 
     73                       
    7474                        async_answer_0(callid, EOK);
    75 
     75                       
    7676                        if (cb_fun != NULL)
    7777                                (*cb_fun)();
    78 
     78                       
    7979                        break;
    8080                default:
    … …  
    8989{
    9090        fibril_mutex_lock(mtx);
    91 
     91       
    9292        if ((*dst == NULL) && (src != NULL))
    9393                *dst = src;
    94 
     94       
    9595        fibril_mutex_unlock(mtx);
    9696}
    … …  
    108108                async_exch_t *exch =
    109109                    loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    110 
     110               
    111111                ipc_call_t answer;
    112112                aid_t req = async_send_0(exch, LOC_CALLBACK_CREATE, &answer);
    113 
     113               
    114114                port_id_t port;
    115115                errno_t rc = async_create_callback_port(exch, INTERFACE_LOC_CB, 0, 0,
    116116                    loc_cb_conn, NULL, &port);
    117 
     117               
    118118                loc_exchange_end(exch);
    119 
     119               
    120120                if (rc != EOK)
    121121                        return rc;
    122 
     122               
    123123                errno_t retval;
    124124                async_wait_for(req, &retval);
    125125                if (retval != EOK)
    126126                        return retval;
    127 
     127               
    128128                loc_callback_created = true;
    129129        }
    130 
     130       
    131131        return EOK;
    132132}
    … …  
    144144        case INTERFACE_LOC_SUPPLIER:
    145145                fibril_mutex_lock(&loc_supp_block_mutex);
    146 
     146               
    147147                while (loc_supp_block_sess == NULL) {
    148148                        clone_session(&loc_supplier_mutex, loc_supplier_sess,
    149149                            &loc_supp_block_sess);
    150 
     150                       
    151151                        if (loc_supp_block_sess == NULL)
    152152                                loc_supp_block_sess =
    … …  
    154154                                    INTERFACE_LOC_SUPPLIER, 0);
    155155                }
    156 
     156               
    157157                fibril_mutex_unlock(&loc_supp_block_mutex);
    158 
     158               
    159159                clone_session(&loc_supplier_mutex, loc_supp_block_sess,
    160160                    &loc_supplier_sess);
    161 
     161               
    162162                return async_exchange_begin(loc_supp_block_sess);
    163163        case INTERFACE_LOC_CONSUMER:
    164164                fibril_mutex_lock(&loc_cons_block_mutex);
    165 
     165               
    166166                while (loc_cons_block_sess == NULL) {
    167167                        clone_session(&loc_consumer_mutex, loc_consumer_sess,
    168168                            &loc_cons_block_sess);
    169 
     169                       
    170170                        if (loc_cons_block_sess == NULL)
    171171                                loc_cons_block_sess =
    … …  
    173173                                    INTERFACE_LOC_CONSUMER, 0);
    174174                }
    175 
     175               
    176176                fibril_mutex_unlock(&loc_cons_block_mutex);
    177 
     177               
    178178                clone_session(&loc_consumer_mutex, loc_cons_block_sess,
    179179                    &loc_consumer_sess);
    180 
     180               
    181181                return async_exchange_begin(loc_cons_block_sess);
    182182        default:
    … …  
    197197        case INTERFACE_LOC_SUPPLIER:
    198198                fibril_mutex_lock(&loc_supplier_mutex);
    199 
     199               
    200200                if (loc_supplier_sess == NULL)
    201201                        loc_supplier_sess =
    202202                            service_connect(SERVICE_LOC,
    203203                            INTERFACE_LOC_SUPPLIER, 0);
    204 
     204               
    205205                fibril_mutex_unlock(&loc_supplier_mutex);
    206 
     206               
    207207                if (loc_supplier_sess == NULL)
    208208                        return NULL;
    209 
     209               
    210210                return async_exchange_begin(loc_supplier_sess);
    211211        case INTERFACE_LOC_CONSUMER:
    212212                fibril_mutex_lock(&loc_consumer_mutex);
    213 
     213               
    214214                if (loc_consumer_sess == NULL)
    215215                        loc_consumer_sess =
    216216                            service_connect(SERVICE_LOC,
    217217                            INTERFACE_LOC_CONSUMER, 0);
    218 
     218               
    219219                fibril_mutex_unlock(&loc_consumer_mutex);
    220 
     220               
    221221                if (loc_consumer_sess == NULL)
    222222                        return NULL;
    223 
     223               
    224224                return async_exchange_begin(loc_consumer_sess);
    225225        default:
    … …  
    242242{
    243243        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    244 
     244       
    245245        ipc_call_t answer;
    246246        aid_t req = async_send_2(exch, LOC_SERVER_REGISTER, 0, 0, &answer);
    247247        errno_t retval = async_data_write_start(exch, name, str_size(name));
    248 
     248       
    249249        if (retval != EOK) {
    250250                async_forget(req);
    … …  
    252252                return retval;
    253253        }
    254 
     254       
    255255        async_connect_to_me(exch, 0, 0, 0);
    256256
    … …  
    262262        async_wait_for(req, &retval);
    263263        loc_exchange_end(exch);
    264 
     264       
    265265        return retval;
    266266}
    … …  
    275275{
    276276        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    277 
     277       
    278278        ipc_call_t answer;
    279279        aid_t req = async_send_0(exch, LOC_SERVICE_REGISTER, &answer);
    280280        errno_t retval = async_data_write_start(exch, fqsn, str_size(fqsn));
    281 
     281       
    282282        if (retval != EOK) {
    283283                async_forget(req);
    … …  
    285285                return retval;
    286286        }
    287 
     287       
    288288        /*
    289289         * First wait for the answer and then end the exchange. The opposite
    … …  
    293293        async_wait_for(req, &retval);
    294294        loc_exchange_end(exch);
    295 
     295       
    296296        if (retval != EOK) {
    297297                if (sid != NULL)
    298298                        *sid = -1;
    299 
    300                 return retval;
    301         }
    302 
     299               
     300                return retval;
     301        }
     302       
    303303        if (sid != NULL)
    304304                *sid = (service_id_t) IPC_GET_ARG1(answer);
    305 
     305       
    306306        return retval;
    307307}
    … …  
    315315        async_exch_t *exch;
    316316        errno_t retval;
    317 
     317       
    318318        exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    319319        retval = async_req_1_0(exch, LOC_SERVICE_UNREGISTER, sid);
    320320        loc_exchange_end(exch);
    321 
     321       
    322322        return (errno_t)retval;
    323323}
    … …  
    327327{
    328328        async_exch_t *exch;
    329 
     329       
    330330        if (flags & IPC_FLAG_BLOCKING)
    331331                exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    … …  
    335335                        return errno;
    336336        }
    337 
     337       
    338338        ipc_call_t answer;
    339339        aid_t req = async_send_2(exch, LOC_SERVICE_GET_ID, flags, 0,
    340340            &answer);
    341341        errno_t retval = async_data_write_start(exch, fqdn, str_size(fqdn));
    342 
    343         loc_exchange_end(exch);
    344 
     342       
     343        loc_exchange_end(exch);
     344       
    345345        if (retval != EOK) {
    346346                async_forget(req);
    347347                return retval;
    348348        }
    349 
     349       
    350350        async_wait_for(req, &retval);
    351 
     351       
    352352        if (retval != EOK) {
    353353                if (handle != NULL)
    354354                        *handle = (service_id_t) -1;
    355 
    356                 return retval;
    357         }
    358 
     355               
     356                return retval;
     357        }
     358       
    359359        if (handle != NULL)
    360360                *handle = (service_id_t) IPC_GET_ARG1(answer);
    361 
     361       
    362362        return retval;
    363363}
    … …  
    380380        size_t act_size;
    381381        errno_t dretval;
    382 
     382       
    383383        *name = NULL;
    384384        exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    385 
     385       
    386386        ipc_call_t answer;
    387387        aid_t req = async_send_1(exch, method, id, &answer);
    … …  
    389389            &dreply);
    390390        async_wait_for(dreq, &dretval);
    391 
    392         loc_exchange_end(exch);
    393 
     391       
     392        loc_exchange_end(exch);
     393       
    394394        if (dretval != EOK) {
    395395                async_forget(req);
    396396                return dretval;
    397397        }
    398 
     398       
    399399        errno_t retval;
    400400        async_wait_for(req, &retval);
    401 
     401       
    402402        if (retval != EOK)
    403403                return retval;
    404 
     404       
    405405        act_size = IPC_GET_ARG2(dreply);
    406406        assert(act_size <= LOC_NAME_MAXLEN);
    … …  
    410410        if (*name == NULL)
    411411                return ENOMEM;
    412 
     412       
    413413        return EOK;
    414414}
    … …  
    460460{
    461461        async_exch_t *exch;
    462 
     462       
    463463        if (flags & IPC_FLAG_BLOCKING)
    464464                exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    … …  
    468468                        return errno;
    469469        }
    470 
     470       
    471471        ipc_call_t answer;
    472472        aid_t req = async_send_2(exch, LOC_NAMESPACE_GET_ID, flags, 0,
    473473            &answer);
    474474        errno_t retval = async_data_write_start(exch, name, str_size(name));
    475 
    476         loc_exchange_end(exch);
    477 
     475       
     476        loc_exchange_end(exch);
     477       
    478478        if (retval != EOK) {
    479479                async_forget(req);
    480480                return retval;
    481481        }
    482 
     482       
    483483        async_wait_for(req, &retval);
    484 
     484       
    485485        if (retval != EOK) {
    486486                if (handle != NULL)
    487487                        *handle = (service_id_t) -1;
    488 
    489                 return retval;
    490         }
    491 
     488               
     489                return retval;
     490        }
     491       
    492492        if (handle != NULL)
    493493                *handle = (service_id_t) IPC_GET_ARG1(answer);
    494 
     494       
    495495        return retval;
    496496}
    … …  
    509509{
    510510        async_exch_t *exch;
    511 
     511       
    512512        if (flags & IPC_FLAG_BLOCKING)
    513513                exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    … …  
    517517                        return errno;
    518518        }
    519 
     519       
    520520        ipc_call_t answer;
    521521        aid_t req = async_send_0(exch, LOC_CATEGORY_GET_ID,
    522522            &answer);
    523523        errno_t retval = async_data_write_start(exch, name, str_size(name));
    524 
    525         loc_exchange_end(exch);
    526 
     524       
     525        loc_exchange_end(exch);
     526       
    527527        if (retval != EOK) {
    528528                async_forget(req);
    529529                return retval;
    530530        }
    531 
     531       
    532532        async_wait_for(req, &retval);
    533 
     533       
    534534        if (retval != EOK) {
    535535                if (cat_id != NULL)
    536536                        *cat_id = (category_id_t) -1;
    537 
    538                 return retval;
    539         }
    540 
     537               
     538                return retval;
     539        }
     540       
    541541        if (cat_id != NULL)
    542542                *cat_id = (category_id_t) IPC_GET_ARG1(answer);
    543 
     543       
    544544        return retval;
    545545}
    … …  
    549549{
    550550        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    551 
     551       
    552552        sysarg_t type;
    553553        errno_t retval = async_req_1_1(exch, LOC_ID_PROBE, handle, &type);
    554 
    555         loc_exchange_end(exch);
    556 
     554       
     555        loc_exchange_end(exch);
     556       
    557557        if (retval != EOK)
    558558                return LOC_OBJECT_NONE;
    559 
     559       
    560560        return (loc_object_type_t) type;
    561561}
    … …  
    565565{
    566566        async_sess_t *sess;
    567 
     567       
    568568        if (flags & IPC_FLAG_BLOCKING)
    569569                sess = service_connect_blocking(SERVICE_LOC, iface, handle);
    570570        else
    571571                sess = service_connect(SERVICE_LOC, iface, handle);
    572 
     572       
    573573        return sess;
    574574}
    … …  
    580580{
    581581        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    582 
     582       
    583583        sysarg_t null_id;
    584584        errno_t retval = async_req_0_1(exch, LOC_NULL_CREATE, &null_id);
    585 
    586         loc_exchange_end(exch);
    587 
     585       
     586        loc_exchange_end(exch);
     587       
    588588        if (retval != EOK)
    589589                return -1;
    590 
     590       
    591591        return (int) null_id;
    592592}
    … …  
    605605        if (retval != EOK)
    606606                return 0;
    607 
     607       
    608608        return count;
    609609}
    … …  
    619619        async_exch_t *exch;
    620620        errno_t retval;
    621 
     621       
    622622        exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    623623        retval = async_req_2_0(exch, LOC_SERVICE_ADD_TO_CAT, svc_id, cat_id);
    624624        loc_exchange_end(exch);
    625 
     625       
    626626        return retval;
    627627}
    … …  
    635635        if (retval != EOK)
    636636                return 0;
    637 
     637       
    638638        return count;
    639639}
    … …  
    644644        size_t size = loc_count_namespaces_internal(exch);
    645645        loc_exchange_end(exch);
    646 
     646       
    647647        return size;
    648648}
    … …  
    653653        size_t size = loc_count_services_internal(exch, ns_handle);
    654654        loc_exchange_end(exch);
    655 
     655       
    656656        return size;
    657657}
    … …  
    664664                size_t count = loc_count_namespaces_internal(exch);
    665665                loc_exchange_end(exch);
    666 
     666               
    667667                if (count == 0)
    668668                        return 0;
    669 
     669               
    670670                loc_sdesc_t *devs = (loc_sdesc_t *) calloc(count, sizeof(loc_sdesc_t));
    671671                if (devs == NULL)
    672672                        return 0;
    673 
     673               
    674674                exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
    675 
     675               
    676676                ipc_call_t answer;
    677677                aid_t req = async_send_0(exch, LOC_GET_NAMESPACES, &answer);
    678678                errno_t rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t));
    679 
     679               
    680680                loc_exchange_end(exch);
    681 
     681               
    682682                if (rc == EOVERFLOW) {
    683683                        /*
    … …  
    688688                        continue;
    689689                }
    690 
     690               
    691691                if (rc != EOK) {
    692692                        async_forget(req);
    … …  
    694694                        return 0;
    695695                }
    696 
     696               
    697697                errno_t retval;
    698698                async_wait_for(req, &retval);
    699 
     699               
    700700                if (retval != EOK)
    701701                        return 0;
    702 
     702               
    703703                *data = devs;
    704704                return count;
    … …  
    713713                size_t count = loc_count_services_internal(exch, ns_handle);
    714714                loc_exchange_end(exch);
    715 
     715               
    716716                if (count == 0)
    717717                        return 0;
    718 
     718               
    719719                loc_sdesc_t *devs = (loc_sdesc_t *) calloc(count, sizeof(loc_sdesc_t));
    720720                if (devs == NULL)
    721721                        return 0;
    722 
     722               
    723723                exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
    724 
     724               
    725725                ipc_call_t answer;
    726726                aid_t req = async_send_1(exch, LOC_GET_SERVICES, ns_handle, &answer);
    727727                errno_t rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t));
    728 
     728               
    729729                loc_exchange_end(exch);
    730 
     730               
    731731                if (rc == EOVERFLOW) {
    732732                        /*
    … …  
    737737                        continue;
    738738                }
    739 
     739               
    740740                if (rc != EOK) {
    741741                        async_forget(req);
    … …  
    743743                        return 0;
    744744                }
    745 
     745               
    746746                errno_t retval;
    747747                async_wait_for(req, &retval);
    748 
     748               
    749749                if (retval != EOK)
    750750                        return 0;
    751 
     751               
    752752                *data = devs;
    753753                return count;
    … …  
    763763        aid_t req = async_send_1(exch, method, arg1, &answer);
    764764        errno_t rc = async_data_read_start(exch, id_buf, buf_size);
    765 
    766         loc_exchange_end(exch);
    767 
     765       
     766        loc_exchange_end(exch);
     767       
    768768        if (rc != EOK) {
    769769                async_forget(req);
    770770                return rc;
    771771        }
    772 
     772       
    773773        errno_t retval;
    774774        async_wait_for(req, &retval);
    775 
    776         if (retval != EOK) {
    777                 return retval;
    778         }
    779 
     775       
     776        if (retval != EOK) {
     777                return retval;
     778        }
     779       
    780780        *act_size = IPC_GET_ARG1(answer);
    781781        return EOK;
    … …  
    797797        *data = NULL;
    798798        *count = 0;
    799 
     799       
    800800        size_t act_size = 0;
    801801        errno_t rc = loc_category_get_ids_once(method, arg1, NULL, 0,
    … …  
    803803        if (rc != EOK)
    804804                return rc;
    805 
     805       
    806806        size_t alloc_size = act_size;
    807807        service_id_t *ids = malloc(alloc_size);
    808808        if (ids == NULL)
    809809                return ENOMEM;
    810 
     810       
    811811        while (true) {
    812812                rc = loc_category_get_ids_once(method, arg1, ids, alloc_size,
    … …  
    814814                if (rc != EOK)
    815815                        return rc;
    816 
     816               
    817817                if (act_size <= alloc_size)
    818818                        break;
    819 
     819               
    820820                alloc_size = act_size;
    821821                ids = realloc(ids, alloc_size);
    … …  
    823823                        return ENOMEM;
    824824        }
    825 
     825       
    826826        *count = act_size / sizeof(category_id_t);
    827827        *data = ids;
    … …  
    866866                return EIO;
    867867        }
    868 
     868       
    869869        cat_change_cb = cb_fun;
    870870        fibril_mutex_unlock(&loc_callback_mutex);
    871 
     871       
    872872        return EOK;
    873873}
Note: See TracChangeset for help on using the changeset viewer.