Changeset f9b2cb4c in mainline for uspace/lib/c/generic/loc.c


Ignore:
Timestamp:
2015-08-23T12:50:23Z (9 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9ef495f
Parents:
0dd16778
Message:

unify interface API

  • introduce new interfaces
  • unify location service clients to always expect service ID as the second argument
  • remove obsolete methods that take explicit exchange management arguments (first phase)
  • use interfaces in device drivers, devman, location service, logger, inet
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r0dd16778 rf9b2cb4c  
    107107        if (!loc_callback_created) {
    108108                async_exch_t *exch =
    109                     loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     109                    loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    110110               
    111111                ipc_call_t answer;
    112112                aid_t req = async_send_0(exch, LOC_CALLBACK_CREATE, &answer);
    113                 int rc = async_connect_to_me(exch, 0, 0, 0, loc_cb_conn, NULL);
     113               
     114                port_id_t port;
     115                int rc = async_create_callback_port(exch, INTERFACE_LOC_CB, 0, 0,
     116                    loc_cb_conn, NULL, &port);
     117               
    114118                loc_exchange_end(exch);
    115119               
    … …  
    135139 *
    136140 */
    137 async_exch_t *loc_exchange_begin_blocking(loc_interface_t iface)
     141async_exch_t *loc_exchange_begin_blocking(iface_t iface)
    138142{
    139143        switch (iface) {
    140         case LOC_PORT_SUPPLIER:
     144        case INTERFACE_LOC_SUPPLIER:
    141145                fibril_mutex_lock(&loc_supp_block_mutex);
    142146               
    … …  
    147151                        if (loc_supp_block_sess == NULL)
    148152                                loc_supp_block_sess =
    149                                     service_connect_blocking_iface(EXCHANGE_SERIALIZE,
    150                                     LOC_PORT_SUPPLIER, SERVICE_LOC, 0);
     153                                    service_connect_blocking(SERVICE_LOC,
     154                                    INTERFACE_LOC_SUPPLIER, 0);
    151155                }
    152156               
    … …  
    157161               
    158162                return async_exchange_begin(loc_supp_block_sess);
    159         case LOC_PORT_CONSUMER:
     163        case INTERFACE_LOC_CONSUMER:
    160164                fibril_mutex_lock(&loc_cons_block_mutex);
    161165               
    … …  
    166170                        if (loc_cons_block_sess == NULL)
    167171                                loc_cons_block_sess =
    168                                     service_connect_blocking_iface(EXCHANGE_SERIALIZE,
    169                                     LOC_PORT_CONSUMER, SERVICE_LOC, 0);
     172                                    service_connect_blocking(SERVICE_LOC,
     173                                    INTERFACE_LOC_CONSUMER, 0);
    170174                }
    171175               
    … …  
    188192 *
    189193 */
    190 async_exch_t *loc_exchange_begin(loc_interface_t iface)
     194async_exch_t *loc_exchange_begin(iface_t iface)
    191195{
    192196        switch (iface) {
    193         case LOC_PORT_SUPPLIER:
     197        case INTERFACE_LOC_SUPPLIER:
    194198                fibril_mutex_lock(&loc_supplier_mutex);
    195199               
    196200                if (loc_supplier_sess == NULL)
    197201                        loc_supplier_sess =
    198                             service_connect_iface(EXCHANGE_SERIALIZE, LOC_PORT_SUPPLIER,
    199                             SERVICE_LOC, 0);
     202                            service_connect(SERVICE_LOC,
     203                            INTERFACE_LOC_SUPPLIER, 0);
    200204               
    201205                fibril_mutex_unlock(&loc_supplier_mutex);
    … …  
    205209               
    206210                return async_exchange_begin(loc_supplier_sess);
    207         case LOC_PORT_CONSUMER:
     211        case INTERFACE_LOC_CONSUMER:
    208212                fibril_mutex_lock(&loc_consumer_mutex);
    209213               
    210214                if (loc_consumer_sess == NULL)
    211215                        loc_consumer_sess =
    212                             service_connect_iface(EXCHANGE_SERIALIZE, LOC_PORT_CONSUMER,
    213                             SERVICE_LOC, 0);
     216                            service_connect(SERVICE_LOC,
     217                            INTERFACE_LOC_CONSUMER, 0);
    214218               
    215219                fibril_mutex_unlock(&loc_consumer_mutex);
    … …  
    237241int loc_server_register(const char *name)
    238242{
    239         async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER);
     243        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    240244       
    241245        ipc_call_t answer;
    … …  
    250254        }
    251255       
    252         exch = loc_exchange_begin(LOC_PORT_SUPPLIER);
    253         async_connect_to_me(exch, 0, 0, 0, NULL, NULL);
     256        exch = loc_exchange_begin(INTERFACE_LOC_SUPPLIER);
     257        async_connect_to_me(exch, 0, 0, 0);
    254258        loc_exchange_end(exch);
    255259       
    … …  
    260264/** Register new service.
    261265 *
    262  * The @p interface is used when forwarding connection to the server.
    263  * If not 0, the first argument is the interface and the second argument
    264  * is the service ID.
    265  *
    266  * When the interface is zero (default), the first argument is directly
    267  * the handle (to ensure backward compatibility).
    268  *
    269  * @param      fqsn      Fully qualified service name
    270  * @param[out] sid       Service ID of new service
    271  * @param      interface Interface when forwarding
    272  *
    273  */
    274 int loc_service_register_with_iface(const char *fqsn,
    275     service_id_t *sid, sysarg_t interface)
    276 {
    277         async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER);
     266 * @param      fqsn  Fully qualified service name
     267 * @param[out] sid   Service ID of new service
     268 *
     269 */
     270int loc_service_register(const char *fqsn, service_id_t *sid)
     271{
     272        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    278273       
    279274        ipc_call_t answer;
    280         aid_t req = async_send_2(exch, LOC_SERVICE_REGISTER, interface, 0,
    281             &answer);
     275        aid_t req = async_send_0(exch, LOC_SERVICE_REGISTER, &answer);
    282276        sysarg_t retval = async_data_write_start(exch, fqsn, str_size(fqsn));
    283277       
    … …  
    304298}
    305299
    306 /** Register new service.
    307  *
    308  * @param fqsn Fully qualified service name
    309  * @param sid  Output: ID of new service
    310  *
    311  */
    312 int loc_service_register(const char *fqdn, service_id_t *sid)
    313 {
    314         return loc_service_register_with_iface(fqdn, sid, 0);
    315 }
    316 
    317300/** Unregister service.
    318301 *
    … …  
    324307        sysarg_t retval;
    325308       
    326         exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER);
     309        exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    327310        retval = async_req_1_0(exch, LOC_SERVICE_UNREGISTER, sid);
    328311        loc_exchange_end(exch);
    … …  
    337320       
    338321        if (flags & IPC_FLAG_BLOCKING)
    339                 exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     322                exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    340323        else {
    341                 exch = loc_exchange_begin(LOC_PORT_CONSUMER);
     324                exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
    342325                if (exch == NULL)
    343326                        return errno;
    … …  
    390373       
    391374        *name = NULL;
    392         exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     375        exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    393376       
    394377        ipc_call_t answer;
    … …  
    470453       
    471454        if (flags & IPC_FLAG_BLOCKING)
    472                 exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     455                exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    473456        else {
    474                 exch = loc_exchange_begin(LOC_PORT_CONSUMER);
     457                exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
    475458                if (exch == NULL)
    476459                        return errno;
    … …  
    519502       
    520503        if (flags & IPC_FLAG_BLOCKING)
    521                 exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     504                exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    522505        else {
    523                 exch = loc_exchange_begin(LOC_PORT_CONSUMER);
     506                exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
    524507                if (exch == NULL)
    525508                        return errno;
    … …  
    556539loc_object_type_t loc_id_probe(service_id_t handle)
    557540{
    558         async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     541        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    559542       
    560543        sysarg_t type;
    … …  
    569552}
    570553
    571 async_sess_t *loc_service_connect_iface(service_id_t handle, iface_t iface,
     554async_sess_t *loc_service_connect(service_id_t handle, iface_t iface,
    572555    unsigned int flags)
    573556{
    … …  
    575558       
    576559        if (flags & IPC_FLAG_BLOCKING)
    577                 sess = service_connect_blocking_iface_extended(SERVICE_LOC, iface, handle);
     560                sess = service_connect_blocking(SERVICE_LOC, iface, handle);
    578561        else
    579                 sess = service_connect_iface_extended(SERVICE_LOC, iface, handle);
     562                sess = service_connect(SERVICE_LOC, iface, handle);
    580563       
    581564        return sess;
    582565}
    583566
    584 async_sess_t *loc_service_connect(exch_mgmt_t mgmt, service_id_t handle,
    585     unsigned int flags)
    586 {
    587         async_sess_t *sess;
    588        
    589         if (flags & IPC_FLAG_BLOCKING)
    590                 sess = service_connect_blocking_iface(mgmt, LOC_CONNECT_TO_SERVICE,
    591                     SERVICE_LOC, handle);
    592         else
    593                 sess = service_connect_iface(mgmt, LOC_CONNECT_TO_SERVICE,
    594                     SERVICE_LOC, handle);
    595        
    596         return sess;
    597 }
    598 
    599567int loc_null_create(void)
    600568{
    601         async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     569        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    602570       
    603571        sysarg_t null_id;
    … …  
    614582void loc_null_destroy(int null_id)
    615583{
    616         async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     584        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    617585        async_req_1_0(exch, LOC_NULL_DESTROY, (sysarg_t) null_id);
    618586        loc_exchange_end(exch);
    … …  
    640608        sysarg_t retval;
    641609       
    642         exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER);
     610        exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    643611        retval = async_req_2_0(exch, LOC_SERVICE_ADD_TO_CAT, svc_id, cat_id);
    644612        loc_exchange_end(exch);
    … …  
    661629size_t loc_count_namespaces(void)
    662630{
    663         async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     631        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    664632        size_t size = loc_count_namespaces_internal(exch);
    665633        loc_exchange_end(exch);
    … …  
    670638size_t loc_count_services(service_id_t ns_handle)
    671639{
    672         async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     640        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    673641        size_t size = loc_count_services_internal(exch, ns_handle);
    674642        loc_exchange_end(exch);
    … …  
    681649        /* Loop until read is succesful */
    682650        while (true) {
    683                 async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     651                async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    684652                size_t count = loc_count_namespaces_internal(exch);
    685653                loc_exchange_end(exch);
    … …  
    692660                        return 0;
    693661               
    694                 exch = loc_exchange_begin(LOC_PORT_CONSUMER);
     662                exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
    695663               
    696664                ipc_call_t answer;
    … …  
    730698        /* Loop until read is succesful */
    731699        while (true) {
    732                 async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     700                async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    733701                size_t count = loc_count_services_internal(exch, ns_handle);
    734702                loc_exchange_end(exch);
    … …  
    741709                        return 0;
    742710               
    743                 exch = loc_exchange_begin(LOC_PORT_CONSUMER);
     711                exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
    744712               
    745713                ipc_call_t answer;
    … …  
    778746    sysarg_t *id_buf, size_t buf_size, size_t *act_size)
    779747{
    780         async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     748        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    781749
    782750        ipc_call_t answer;
Note: See TracChangeset for help on using the changeset viewer.