Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r5a6cc679 ra35b458  
    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.