Changeset 4c6fd56 in mainline for uspace/lib


Ignore:
Timestamp:
2023-09-16T19:58:18Z (2 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
7d7f5e3
Parents:
6a0b2cc
git-author:
Jiri Svoboda <jiri@…> (2023-09-16 19:48:07)
git-committer:
Jiri Svoboda <jiri@…> (2023-09-16 19:58:18)
Message:

loc_server_register() should be callable more than once (API only)

Now loc_server_register() returns a pointer to a loc_srv_t object,
that is then passed to loc_service_register() and
loc_service_add_to_cat().

Added loc_server_unregister() that unregisters the server
and frees the loc_srv_t object.

Updated all callers. The implementation, however, is a stub.
It is not actually possible to call loc_server_register() more
than once, yet.

Location:
uspace/lib
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed

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

    r6a0b2cc r4c6fd56  
    11/*
     2 * Copyright (c) 2023 Jiri Svoboda
    23 * Copyright (c) 2007 Josef Cejka
    3  * Copyright (c) 2011 Jiri Svoboda
    44 * All rights reserved.
    55 *
    … …  
    239239}
    240240
    241 /** Register new server with loc. */
    242 errno_t loc_server_register(const char *name)
    243 {
    244         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
     241/** Register new server with loc.
     242 *
     243 * XXX Proper impementation - currently cannot actually call
     244 * this function more than once.
     245 *
     246 * @param name Server name
     247 * @param rsrv Place to store new server object on success
     248 * @return EOK on succes or an error code
     249 */
     250errno_t loc_server_register(const char *name, loc_srv_t **rsrv)
     251{
     252        async_exch_t *exch;
     253        loc_srv_t *srv;
     254
     255        srv = calloc(1, sizeof(loc_srv_t));
     256        if (srv == NULL)
     257                return ENOMEM;
     258
     259        exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    245260
    246261        ipc_call_t answer;
    … …  
    251266                async_forget(req);
    252267                loc_exchange_end(exch);
     268                free(srv);
    253269                return retval;
    254270        }
    … …  
    264280        loc_exchange_end(exch);
    265281
     282        if (retval != EOK) {
     283                free(srv);
     284                return retval;
     285        }
     286
     287        *rsrv = srv;
    266288        return retval;
    267289}
    268290
     291/** Unregister server from loc.
     292 *
     293 * Unregister server and free server object.
     294 *
     295 * XXX Proper implementation
     296 *
     297 * @param srv Server object
     298 */
     299void loc_server_unregister(loc_srv_t *srv)
     300{
     301        free(srv);
     302}
     303
    269304/** Register new service.
    270305 *
    271  * @param      fqsn  Fully qualified service name
    272  * @param[out] sid   Service ID of new service
    273  *
    274  */
    275 errno_t loc_service_register(const char *fqsn, service_id_t *sid)
     306 * @param srv Server object
     307 * @param fqsn Fully qualified service name
     308 * @param sid  Service ID of new service
     309 *
     310 */
     311errno_t loc_service_register(loc_srv_t *srv, const char *fqsn,
     312    service_id_t *sid)
    276313{
    277314        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
     315
     316        (void)srv;
    278317
    279318        ipc_call_t answer;
    … …  
    310349/** Unregister service.
    311350 *
    312  * @param sid   Service ID
    313  */
    314 errno_t loc_service_unregister(service_id_t sid)
     351 * @param srv Server object
     352 * @param sid Service ID
     353 */
     354errno_t loc_service_unregister(loc_srv_t *srv, service_id_t sid)
    315355{
    316356        async_exch_t *exch;
    317357        errno_t retval;
     358
     359        (void)srv;
    318360
    319361        exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    … …  
    611653/** Add service to category.
    612654 *
    613  * @param svc_id        Service ID
    614  * @param cat_id        Category ID
    615  * @return              EOK on success or an error code
    616  */
    617 errno_t loc_service_add_to_cat(service_id_t svc_id, service_id_t cat_id)
     655 * @param srv    Server object
     656 * @param svc_id Service ID
     657 * @param cat_id Category ID
     658 *
     659 * @return EOK on success or an error code
     660 */
     661errno_t loc_service_add_to_cat(loc_srv_t *srv, service_id_t svc_id,
     662    service_id_t cat_id)
    618663{
    619664        async_exch_t *exch;

  • uspace/lib/c/include/loc.h

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3939#include <async.h>
    4040#include <stdbool.h>
     41#include <types/loc.h>
    4142
    4243typedef void (*loc_cat_change_cb_t)(void *);
    … …  
    4647extern void loc_exchange_end(async_exch_t *);
    4748
    48 extern errno_t loc_server_register(const char *);
    49 extern errno_t loc_service_register(const char *, service_id_t *);
    50 extern errno_t loc_service_unregister(service_id_t);
    51 extern errno_t loc_service_add_to_cat(service_id_t, category_id_t);
     49extern errno_t loc_server_register(const char *, loc_srv_t **);
     50extern void loc_server_unregister(loc_srv_t *);
     51extern errno_t loc_service_register(loc_srv_t *, const char *, service_id_t *);
     52extern errno_t loc_service_unregister(loc_srv_t *, service_id_t);
     53extern errno_t loc_service_add_to_cat(loc_srv_t *, service_id_t, category_id_t);
    5254
    5355extern errno_t loc_service_get_id(const char *, service_id_t *,

  • uspace/lib/ddev/test/ddev.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2019 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    7878        ddev_t *ddev = NULL;
    7979        test_response_t resp;
    80 
    81         async_set_fallback_port_handler(test_ddev_conn, &resp);
    82 
    83         // FIXME This causes this test to be non-reentrant!
    84         rc = loc_server_register(test_ddev_server);
    85         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    86 
    87         rc = loc_service_register(test_ddev_svc, &sid);
    88         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    89 
    90         rc = ddev_open(test_ddev_svc, &ddev);
    91         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    92         PCUT_ASSERT_NOT_NULL(ddev);
    93 
    94         ddev_close(ddev);
    95         rc = loc_service_unregister(sid);
    96         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     80        loc_srv_t *srv;
     81
     82        async_set_fallback_port_handler(test_ddev_conn, &resp);
     83
     84        // FIXME This causes this test to be non-reentrant!
     85        rc = loc_server_register(test_ddev_server, &srv);
     86        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     87
     88        rc = loc_service_register(srv, test_ddev_svc, &sid);
     89        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     90
     91        rc = ddev_open(test_ddev_svc, &ddev);
     92        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     93        PCUT_ASSERT_NOT_NULL(ddev);
     94
     95        ddev_close(ddev);
     96        rc = loc_service_unregister(srv, sid);
     97        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     98        loc_server_unregister(srv);
    9799}
    98100
    … …  
    105107        test_response_t resp;
    106108        gfx_context_t *gc;
    107 
    108         async_set_fallback_port_handler(test_ddev_conn, &resp);
    109 
    110         // FIXME This causes this test to be non-reentrant!
    111         rc = loc_server_register(test_ddev_server);
    112         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    113 
    114         rc = loc_service_register(test_ddev_svc, &sid);
     109        loc_srv_t *srv;
     110
     111        async_set_fallback_port_handler(test_ddev_conn, &resp);
     112
     113        // FIXME This causes this test to be non-reentrant!
     114        rc = loc_server_register(test_ddev_server, &srv);
     115        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     116
     117        rc = loc_service_register(srv, test_ddev_svc, &sid);
    115118        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    116119
    … …  
    126129
    127130        ddev_close(ddev);
    128         rc = loc_service_unregister(sid);
    129         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     131        rc = loc_service_unregister(srv, sid);
     132        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     133        loc_server_unregister(srv);
    130134}
    131135
    … …  
    139143        gfx_context_t *gc;
    140144        gfx_color_t *color;
    141 
    142         async_set_fallback_port_handler(test_ddev_conn, &resp);
    143 
    144         // FIXME This causes this test to be non-reentrant!
    145         rc = loc_server_register(test_ddev_server);
    146         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    147 
    148         rc = loc_service_register(test_ddev_svc, &sid);
     145        loc_srv_t *srv;
     146
     147        async_set_fallback_port_handler(test_ddev_conn, &resp);
     148
     149        // FIXME This causes this test to be non-reentrant!
     150        rc = loc_server_register(test_ddev_server, &srv);
     151        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     152
     153        rc = loc_service_register(srv, test_ddev_svc, &sid);
    149154        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    150155
    … …  
    170175
    171176        ddev_close(ddev);
    172         rc = loc_service_unregister(sid);
    173         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     177        rc = loc_service_unregister(srv, sid);
     178        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     179        loc_server_unregister(srv);
    174180}
    175181
    … …  
    182188        test_response_t resp;
    183189        ddev_info_t info;
    184 
    185         async_set_fallback_port_handler(test_ddev_conn, &resp);
    186 
    187         // FIXME This causes this test to be non-reentrant!
    188         rc = loc_server_register(test_ddev_server);
    189         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    190 
    191         rc = loc_service_register(test_ddev_svc, &sid);
     190        loc_srv_t *srv;
     191
     192        async_set_fallback_port_handler(test_ddev_conn, &resp);
     193
     194        // FIXME This causes this test to be non-reentrant!
     195        rc = loc_server_register(test_ddev_server, &srv);
     196        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     197
     198        rc = loc_service_register(srv, test_ddev_svc, &sid);
    192199        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    193200
    … …  
    201208
    202209        ddev_close(ddev);
    203         rc = loc_service_unregister(sid);
    204         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     210        rc = loc_service_unregister(srv, sid);
     211        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     212        loc_server_unregister(srv);
    205213}
    206214
    … …  
    213221        test_response_t resp;
    214222        ddev_info_t info;
    215 
    216         async_set_fallback_port_handler(test_ddev_conn, &resp);
    217 
    218         // FIXME This causes this test to be non-reentrant!
    219         rc = loc_server_register(test_ddev_server);
    220         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    221 
    222         rc = loc_service_register(test_ddev_svc, &sid);
     223        loc_srv_t *srv;
     224
     225        async_set_fallback_port_handler(test_ddev_conn, &resp);
     226
     227        // FIXME This causes this test to be non-reentrant!
     228        rc = loc_server_register(test_ddev_server, &srv);
     229        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     230
     231        rc = loc_service_register(srv, test_ddev_svc, &sid);
    223232        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    224233
    … …  
    244253
    245254        ddev_close(ddev);
    246         rc = loc_service_unregister(sid);
    247         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     255        rc = loc_service_unregister(srv, sid);
     256        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     257        loc_server_unregister(srv);
    248258}
    249259

  • uspace/lib/dispcfg/test/dispcfg.c

    r6a0b2cc r4c6fd56  
    5252        dispcfg_t *dispcfg = NULL;
    5353        test_response_t resp;
    54 
    55         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    56 
    57         // FIXME This causes this test to be non-reentrant!
    58         rc = loc_server_register(test_dispcfg_server);
    59         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    60 
    61         rc = loc_service_register(test_dispcfg_svc, &sid);
    62         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    63 
    64         rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
    65         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    66         PCUT_ASSERT_NOT_NULL(dispcfg);
    67 
    68         dispcfg_close(dispcfg);
    69         rc = loc_service_unregister(sid);
    70         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     54        loc_srv_t *srv;
     55
     56        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     57
     58        // FIXME This causes this test to be non-reentrant!
     59        rc = loc_server_register(test_dispcfg_server, &srv);
     60        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     61
     62        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     63        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     64
     65        rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
     66        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     67        PCUT_ASSERT_NOT_NULL(dispcfg);
     68
     69        dispcfg_close(dispcfg);
     70        rc = loc_service_unregister(srv, sid);
     71        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     72        loc_server_unregister(srv);
    7173}
    7274
    … …  
    7981        dispcfg_seat_list_t *list;
    8082        test_response_t resp;
    81 
    82         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    83 
    84         // FIXME This causes this test to be non-reentrant!
    85         rc = loc_server_register(test_dispcfg_server);
    86         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    87 
    88         rc = loc_service_register(test_dispcfg_svc, &sid);
     83        loc_srv_t *srv;
     84
     85        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     86
     87        // FIXME This causes this test to be non-reentrant!
     88        rc = loc_server_register(test_dispcfg_server, &srv);
     89        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     90
     91        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    8992        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9093
    … …  
    101104
    102105        dispcfg_close(dispcfg);
    103         rc = loc_service_unregister(sid);
    104         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     106        rc = loc_service_unregister(srv, sid);
     107        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     108        loc_server_unregister(srv);
    105109}
    106110
    … …  
    113117        dispcfg_seat_list_t *list;
    114118        test_response_t resp;
    115 
    116         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    117 
    118         // FIXME This causes this test to be non-reentrant!
    119         rc = loc_server_register(test_dispcfg_server);
    120         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    121 
    122         rc = loc_service_register(test_dispcfg_svc, &sid);
     119        loc_srv_t *srv;
     120
     121        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     122
     123        // FIXME This causes this test to be non-reentrant!
     124        rc = loc_server_register(test_dispcfg_server, &srv);
     125        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     126
     127        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    123128        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    124129
    … …  
    147152        dispcfg_free_seat_list(list);
    148153        dispcfg_close(dispcfg);
    149         rc = loc_service_unregister(sid);
    150         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     154        rc = loc_service_unregister(srv, sid);
     155        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     156        loc_server_unregister(srv);
    151157}
    152158
    … …  
    160166        dispcfg_seat_info_t *info;
    161167        test_response_t resp;
    162 
    163         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    164 
    165         // FIXME This causes this test to be non-reentrant!
    166         rc = loc_server_register(test_dispcfg_server);
    167         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    168 
    169         rc = loc_service_register(test_dispcfg_svc, &sid);
     168        loc_srv_t *srv;
     169
     170        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     171
     172        // FIXME This causes this test to be non-reentrant!
     173        rc = loc_server_register(test_dispcfg_server, &srv);
     174        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     175
     176        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    170177        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    171178
    … …  
    184191
    185192        dispcfg_close(dispcfg);
    186         rc = loc_service_unregister(sid);
    187         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     193        rc = loc_service_unregister(srv, sid);
     194        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     195        loc_server_unregister(srv);
    188196}
    189197
    … …  
    197205        dispcfg_seat_info_t *info;
    198206        test_response_t resp;
    199 
    200         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    201 
    202         // FIXME This causes this test to be non-reentrant!
    203         rc = loc_server_register(test_dispcfg_server);
    204         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    205 
    206         rc = loc_service_register(test_dispcfg_svc, &sid);
     207        loc_srv_t *srv;
     208
     209        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     210
     211        // FIXME This causes this test to be non-reentrant!
     212        rc = loc_server_register(test_dispcfg_server, &srv);
     213        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     214
     215        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    207216        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    208217
    … …  
    228237        dispcfg_free_seat_info(info);
    229238        dispcfg_close(dispcfg);
    230         rc = loc_service_unregister(sid);
    231         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     239        rc = loc_service_unregister(srv, sid);
     240        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     241        loc_server_unregister(srv);
    232242}
    233243
    … …  
    240250        sysarg_t seat_id;
    241251        test_response_t resp;
    242 
    243         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    244 
    245         // FIXME This causes this test to be non-reentrant!
    246         rc = loc_server_register(test_dispcfg_server);
    247         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    248 
    249         rc = loc_service_register(test_dispcfg_svc, &sid);
     252        loc_srv_t *srv;
     253
     254        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     255
     256        // FIXME This causes this test to be non-reentrant!
     257        rc = loc_server_register(test_dispcfg_server, &srv);
     258        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     259
     260        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    250261        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    251262
    … …  
    266277
    267278        dispcfg_close(dispcfg);
    268         rc = loc_service_unregister(sid);
    269         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     279        rc = loc_service_unregister(srv, sid);
     280        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     281        loc_server_unregister(srv);
    270282}
    271283
    … …  
    278290        sysarg_t seat_id;
    279291        test_response_t resp;
    280 
    281         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    282 
    283         // FIXME This causes this test to be non-reentrant!
    284         rc = loc_server_register(test_dispcfg_server);
    285         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    286 
    287         rc = loc_service_register(test_dispcfg_svc, &sid);
     292        loc_srv_t *srv;
     293
     294        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     295
     296        // FIXME This causes this test to be non-reentrant!
     297        rc = loc_server_register(test_dispcfg_server, &srv);
     298        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     299
     300        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    288301        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    289302
    … …  
    304317
    305318        dispcfg_close(dispcfg);
    306         rc = loc_service_unregister(sid);
    307         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     319        rc = loc_service_unregister(srv, sid);
     320        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     321        loc_server_unregister(srv);
    308322}
    309323
    … …  
    316330        sysarg_t seat_id;
    317331        test_response_t resp;
    318 
    319         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    320 
    321         // FIXME This causes this test to be non-reentrant!
    322         rc = loc_server_register(test_dispcfg_server);
    323         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    324 
    325         rc = loc_service_register(test_dispcfg_svc, &sid);
     332        loc_srv_t *srv;
     333
     334        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     335
     336        // FIXME This causes this test to be non-reentrant!
     337        rc = loc_server_register(test_dispcfg_server, &srv);
     338        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     339
     340        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    326341        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    327342
    … …  
    340355
    341356        dispcfg_close(dispcfg);
    342         rc = loc_service_unregister(sid);
    343         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     357        rc = loc_service_unregister(srv, sid);
     358        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     359        loc_server_unregister(srv);
    344360}
    345361
    … …  
    352368        sysarg_t seat_id;
    353369        test_response_t resp;
    354 
    355         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    356 
    357         // FIXME This causes this test to be non-reentrant!
    358         rc = loc_server_register(test_dispcfg_server);
    359         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    360 
    361         rc = loc_service_register(test_dispcfg_svc, &sid);
     370        loc_srv_t *srv;
     371
     372        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     373
     374        // FIXME This causes this test to be non-reentrant!
     375        rc = loc_server_register(test_dispcfg_server, &srv);
     376        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     377
     378        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    362379        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    363380
    … …  
    376393
    377394        dispcfg_close(dispcfg);
    378         rc = loc_service_unregister(sid);
    379         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     395        rc = loc_service_unregister(srv, sid);
     396        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     397        loc_server_unregister(srv);
    380398}
    381399
    … …  
    389407        sysarg_t seat_id;
    390408        test_response_t resp;
    391 
    392         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    393 
    394         // FIXME This causes this test to be non-reentrant!
    395         rc = loc_server_register(test_dispcfg_server);
    396         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    397 
    398         rc = loc_service_register(test_dispcfg_svc, &sid);
     409        loc_srv_t *srv;
     410
     411        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     412
     413        // FIXME This causes this test to be non-reentrant!
     414        rc = loc_server_register(test_dispcfg_server, &srv);
     415        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     416
     417        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    399418        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    400419
    … …  
    415434
    416435        dispcfg_close(dispcfg);
    417         rc = loc_service_unregister(sid);
    418         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     436        rc = loc_service_unregister(srv, sid);
     437        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     438        loc_server_unregister(srv);
    419439}
    420440
    … …  
    428448        sysarg_t seat_id;
    429449        test_response_t resp;
    430 
    431         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    432 
    433         // FIXME This causes this test to be non-reentrant!
    434         rc = loc_server_register(test_dispcfg_server);
    435         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    436 
    437         rc = loc_service_register(test_dispcfg_svc, &sid);
     450        loc_srv_t *srv;
     451
     452        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     453
     454        // FIXME This causes this test to be non-reentrant!
     455        rc = loc_server_register(test_dispcfg_server, &srv);
     456        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     457
     458        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    438459        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    439460
    … …  
    454475
    455476        dispcfg_close(dispcfg);
    456         rc = loc_service_unregister(sid);
    457         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     477        rc = loc_service_unregister(srv, sid);
     478        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     479        loc_server_unregister(srv);
    458480}
    459481
    … …  
    466488        sysarg_t svc_id;
    467489        test_response_t resp;
    468 
    469         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    470 
    471         // FIXME This causes this test to be non-reentrant!
    472         rc = loc_server_register(test_dispcfg_server);
    473         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    474 
    475         rc = loc_service_register(test_dispcfg_svc, &sid);
     490        loc_srv_t *srv;
     491
     492        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     493
     494        // FIXME This causes this test to be non-reentrant!
     495        rc = loc_server_register(test_dispcfg_server, &srv);
     496        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     497
     498        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    476499        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    477500
    … …  
    490513
    491514        dispcfg_close(dispcfg);
    492         rc = loc_service_unregister(sid);
    493         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     515        rc = loc_service_unregister(srv, sid);
     516        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     517        loc_server_unregister(srv);
    494518}
    495519
    … …  
    502526        sysarg_t svc_id;
    503527        test_response_t resp;
    504 
    505         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    506 
    507         // FIXME This causes this test to be non-reentrant!
    508         rc = loc_server_register(test_dispcfg_server);
    509         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    510 
    511         rc = loc_service_register(test_dispcfg_svc, &sid);
     528        loc_srv_t *srv;
     529
     530        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     531
     532        // FIXME This causes this test to be non-reentrant!
     533        rc = loc_server_register(test_dispcfg_server, &srv);
     534        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     535
     536        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    512537        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    513538
    … …  
    526551
    527552        dispcfg_close(dispcfg);
    528         rc = loc_service_unregister(sid);
    529         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     553        rc = loc_service_unregister(srv, sid);
     554        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     555        loc_server_unregister(srv);
    530556}
    531557
    … …  
    539565        sysarg_t seat_id;
    540566        test_response_t resp;
    541 
    542         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    543 
    544         // FIXME This causes this test to be non-reentrant!
    545         rc = loc_server_register(test_dispcfg_server);
    546         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    547 
    548         rc = loc_service_register(test_dispcfg_svc, &sid);
     567        loc_srv_t *srv;
     568
     569        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     570
     571        // FIXME This causes this test to be non-reentrant!
     572        rc = loc_server_register(test_dispcfg_server, &srv);
     573        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     574
     575        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    549576        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    550577
    … …  
    563590
    564591        dispcfg_close(dispcfg);
    565         rc = loc_service_unregister(sid);
    566         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     592        rc = loc_service_unregister(srv, sid);
     593        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     594        loc_server_unregister(srv);
    567595}
    568596
    … …  
    576604        sysarg_t seat_id;
    577605        test_response_t resp;
    578 
    579         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    580 
    581         // FIXME This causes this test to be non-reentrant!
    582         rc = loc_server_register(test_dispcfg_server);
    583         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    584 
    585         rc = loc_service_register(test_dispcfg_svc, &sid);
     606        loc_srv_t *srv;
     607
     608        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     609
     610        // FIXME This causes this test to be non-reentrant!
     611        rc = loc_server_register(test_dispcfg_server, &srv);
     612        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     613
     614        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    586615        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    587616
    … …  
    612641        dispcfg_free_dev_list(list);
    613642        dispcfg_close(dispcfg);
    614         rc = loc_service_unregister(sid);
    615         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     643        rc = loc_service_unregister(srv, sid);
     644        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     645        loc_server_unregister(srv);
    616646}
    617647
    … …  
    623653        dispcfg_t *dispcfg = NULL;
    624654        test_response_t resp;
    625 
    626         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    627 
    628         // FIXME This causes this test to be non-reentrant!
    629         rc = loc_server_register(test_dispcfg_server);
    630         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    631 
    632         rc = loc_service_register(test_dispcfg_svc, &sid);
     655        loc_srv_t *srv;
     656
     657        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     658
     659        // FIXME This causes this test to be non-reentrant!
     660        rc = loc_server_register(test_dispcfg_server, &srv);
     661        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     662
     663        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    633664        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    634665
    … …  
    659690        dispcfg_close(dispcfg);
    660691
    661         rc = loc_service_unregister(sid);
    662         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     692        rc = loc_service_unregister(srv, sid);
     693        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     694        loc_server_unregister(srv);
    663695}
    664696
    … …  
    670702        dispcfg_t *dispcfg = NULL;
    671703        test_response_t resp;
    672 
    673         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    674 
    675         // FIXME This causes this test to be non-reentrant!
    676         rc = loc_server_register(test_dispcfg_server);
    677         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    678 
    679         rc = loc_service_register(test_dispcfg_svc, &sid);
     704        loc_srv_t *srv;
     705
     706        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     707
     708        // FIXME This causes this test to be non-reentrant!
     709        rc = loc_server_register(test_dispcfg_server, &srv);
     710        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     711
     712        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    680713        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    681714
    … …  
    706739        dispcfg_close(dispcfg);
    707740
    708         rc = loc_service_unregister(sid);
    709         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     741        rc = loc_service_unregister(srv, sid);
     742        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     743        loc_server_unregister(srv);
    710744}
    711745

  • uspace/lib/display/test/display.c

    r6a0b2cc r4c6fd56  
    186186        display_t *disp = NULL;
    187187        test_response_t resp;
    188 
    189         async_set_fallback_port_handler(test_display_conn, &resp);
    190 
    191         // FIXME This causes this test to be non-reentrant!
    192         rc = loc_server_register(test_display_server);
    193         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    194 
    195         rc = loc_service_register(test_display_svc, &sid);
    196         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    197 
    198         rc = display_open(test_display_svc, &disp);
    199         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    200         PCUT_ASSERT_NOT_NULL(disp);
    201 
    202         display_close(disp);
    203         rc = loc_service_unregister(sid);
    204         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     188        loc_srv_t *srv;
     189
     190        async_set_fallback_port_handler(test_display_conn, &resp);
     191
     192        // FIXME This causes this test to be non-reentrant!
     193        rc = loc_server_register(test_display_server, &srv);
     194        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     195
     196        rc = loc_service_register(srv, test_display_svc, &sid);
     197        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     198
     199        rc = display_open(test_display_svc, &disp);
     200        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     201        PCUT_ASSERT_NOT_NULL(disp);
     202
     203        display_close(disp);
     204        rc = loc_service_unregister(srv, sid);
     205        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     206        loc_server_unregister(srv);
    205207}
    206208
    … …  
    214216        display_window_t *wnd;
    215217        test_response_t resp;
    216 
    217         async_set_fallback_port_handler(test_display_conn, &resp);
    218 
    219         // FIXME This causes this test to be non-reentrant!
    220         rc = loc_server_register(test_display_server);
    221         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    222 
    223         rc = loc_service_register(test_display_svc, &sid);
     218        loc_srv_t *srv;
     219
     220        async_set_fallback_port_handler(test_display_conn, &resp);
     221
     222        // FIXME This causes this test to be non-reentrant!
     223        rc = loc_server_register(test_display_server, &srv);
     224        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     225
     226        rc = loc_service_register(srv, test_display_svc, &sid);
    224227        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    225228
    … …  
    254257
    255258        display_close(disp);
    256         rc = loc_service_unregister(sid);
    257         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     259        rc = loc_service_unregister(srv, sid);
     260        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     261        loc_server_unregister(srv);
    258262}
    259263
    … …  
    270274        display_window_t *wnd;
    271275        test_response_t resp;
    272 
    273         async_set_fallback_port_handler(test_display_conn, &resp);
    274 
    275         // FIXME This causes this test to be non-reentrant!
    276         rc = loc_server_register(test_display_server);
    277         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    278 
    279         rc = loc_service_register(test_display_svc, &sid);
     276        loc_srv_t *srv;
     277
     278        async_set_fallback_port_handler(test_display_conn, &resp);
     279
     280        // FIXME This causes this test to be non-reentrant!
     281        rc = loc_server_register(test_display_server, &srv);
     282        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     283
     284        rc = loc_service_register(srv, test_display_svc, &sid);
    280285        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    281286
    … …  
    312317
    313318        display_close(disp);
    314         rc = loc_service_unregister(sid);
    315         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     319        rc = loc_service_unregister(srv, sid);
     320        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     321        loc_server_unregister(srv);
    316322}
    317323
    … …  
    325331        display_window_t *wnd;
    326332        test_response_t resp;
    327 
    328         async_set_fallback_port_handler(test_display_conn, &resp);
    329 
    330         // FIXME This causes this test to be non-reentrant!
    331         rc = loc_server_register(test_display_server);
    332         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    333 
    334         rc = loc_service_register(test_display_svc, &sid);
     333        loc_srv_t *srv;
     334
     335        async_set_fallback_port_handler(test_display_conn, &resp);
     336
     337        // FIXME This causes this test to be non-reentrant!
     338        rc = loc_server_register(test_display_server, &srv);
     339        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     340
     341        rc = loc_service_register(srv, test_display_svc, &sid);
    335342        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    336343
    … …  
    365372
    366373        display_close(disp);
    367         rc = loc_service_unregister(sid);
    368         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     374        rc = loc_service_unregister(srv, sid);
     375        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     376        loc_server_unregister(srv);
    369377}
    370378
    … …  
    386394        gfx_coord2_t pos;
    387395        sysarg_t pos_id;
    388 
    389         async_set_fallback_port_handler(test_display_conn, &resp);
    390 
    391         // FIXME This causes this test to be non-reentrant!
    392         rc = loc_server_register(test_display_server);
    393         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    394 
    395         rc = loc_service_register(test_display_svc, &sid);
     396        loc_srv_t *srv;
     397
     398        async_set_fallback_port_handler(test_display_conn, &resp);
     399
     400        // FIXME This causes this test to be non-reentrant!
     401        rc = loc_server_register(test_display_server, &srv);
     402        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     403
     404        rc = loc_service_register(srv, test_display_svc, &sid);
    396405        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    397406
    … …  
    429438        display_window_destroy(wnd);
    430439        display_close(disp);
    431         rc = loc_service_unregister(sid);
    432         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     440        rc = loc_service_unregister(srv, sid);
     441        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     442        loc_server_unregister(srv);
    433443}
    434444
    … …  
    444454        gfx_coord2_t pos;
    445455        sysarg_t pos_id;
    446 
    447         async_set_fallback_port_handler(test_display_conn, &resp);
    448 
    449         // FIXME This causes this test to be non-reentrant!
    450         rc = loc_server_register(test_display_server);
    451         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    452 
    453         rc = loc_service_register(test_display_svc, &sid);
     456        loc_srv_t *srv;
     457
     458        async_set_fallback_port_handler(test_display_conn, &resp);
     459
     460        // FIXME This causes this test to be non-reentrant!
     461        rc = loc_server_register(test_display_server, &srv);
     462        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     463
     464        rc = loc_service_register(srv, test_display_svc, &sid);
    454465        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    455466
    … …  
    487498        display_window_destroy(wnd);
    488499        display_close(disp);
    489         rc = loc_service_unregister(sid);
    490         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     500        rc = loc_service_unregister(srv, sid);
     501        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     502        loc_server_unregister(srv);
    491503}
    492504
    … …  
    501513        gfx_coord2_t dpos;
    502514        test_response_t resp;
    503 
    504         async_set_fallback_port_handler(test_display_conn, &resp);
    505 
    506         // FIXME This causes this test to be non-reentrant!
    507         rc = loc_server_register(test_display_server);
    508         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    509 
    510         rc = loc_service_register(test_display_svc, &sid);
     515        loc_srv_t *srv;
     516
     517        async_set_fallback_port_handler(test_display_conn, &resp);
     518
     519        // FIXME This causes this test to be non-reentrant!
     520        rc = loc_server_register(test_display_server, &srv);
     521        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     522
     523        rc = loc_service_register(srv, test_display_svc, &sid);
    511524        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    512525
    … …  
    541554        display_window_destroy(wnd);
    542555        display_close(disp);
    543         rc = loc_service_unregister(sid);
    544         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     556        rc = loc_service_unregister(srv, sid);
     557        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     558        loc_server_unregister(srv);
    545559}
    546560
    … …  
    555569        gfx_coord2_t dpos;
    556570        test_response_t resp;
    557 
    558         async_set_fallback_port_handler(test_display_conn, &resp);
    559 
    560         // FIXME This causes this test to be non-reentrant!
    561         rc = loc_server_register(test_display_server);
    562         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    563 
    564         rc = loc_service_register(test_display_svc, &sid);
     571        loc_srv_t *srv;
     572
     573        async_set_fallback_port_handler(test_display_conn, &resp);
     574
     575        // FIXME This causes this test to be non-reentrant!
     576        rc = loc_server_register(test_display_server, &srv);
     577        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     578
     579        rc = loc_service_register(srv, test_display_svc, &sid);
    565580        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    566581
    … …  
    595610        display_window_destroy(wnd);
    596611        display_close(disp);
    597         rc = loc_service_unregister(sid);
    598         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     612        rc = loc_service_unregister(srv, sid);
     613        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     614        loc_server_unregister(srv);
    599615}
    600616
    … …  
    609625        gfx_coord2_t dpos;
    610626        test_response_t resp;
    611 
    612         async_set_fallback_port_handler(test_display_conn, &resp);
    613 
    614         // FIXME This causes this test to be non-reentrant!
    615         rc = loc_server_register(test_display_server);
    616         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    617 
    618         rc = loc_service_register(test_display_svc, &sid);
     627        loc_srv_t *srv;
     628
     629        async_set_fallback_port_handler(test_display_conn, &resp);
     630
     631        // FIXME This causes this test to be non-reentrant!
     632        rc = loc_server_register(test_display_server, &srv);
     633        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     634
     635        rc = loc_service_register(srv, test_display_svc, &sid);
    619636        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    620637
    … …  
    650667        display_window_destroy(wnd);
    651668        display_close(disp);
    652         rc = loc_service_unregister(sid);
    653         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     669        rc = loc_service_unregister(srv, sid);
     670        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     671        loc_server_unregister(srv);
    654672}
    655673
    … …  
    664682        gfx_coord2_t dpos;
    665683        test_response_t resp;
    666 
    667         async_set_fallback_port_handler(test_display_conn, &resp);
    668 
    669         // FIXME This causes this test to be non-reentrant!
    670         rc = loc_server_register(test_display_server);
    671         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    672 
    673         rc = loc_service_register(test_display_svc, &sid);
     684        loc_srv_t *srv;
     685
     686        async_set_fallback_port_handler(test_display_conn, &resp);
     687
     688        // FIXME This causes this test to be non-reentrant!
     689        rc = loc_server_register(test_display_server, &srv);
     690        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     691
     692        rc = loc_service_register(srv, test_display_svc, &sid);
    674693        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    675694
    … …  
    707726        display_window_destroy(wnd);
    708727        display_close(disp);
    709         rc = loc_service_unregister(sid);
    710         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     728        rc = loc_service_unregister(srv, sid);
     729        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     730        loc_server_unregister(srv);
    711731}
    712732
    … …  
    721741        gfx_rect_t rect;
    722742        test_response_t resp;
    723 
    724         async_set_fallback_port_handler(test_display_conn, &resp);
    725 
    726         // FIXME This causes this test to be non-reentrant!
    727         rc = loc_server_register(test_display_server);
    728         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    729 
    730         rc = loc_service_register(test_display_svc, &sid);
     743        loc_srv_t *srv;
     744
     745        async_set_fallback_port_handler(test_display_conn, &resp);
     746
     747        // FIXME This causes this test to be non-reentrant!
     748        rc = loc_server_register(test_display_server, &srv);
     749        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     750
     751        rc = loc_service_register(srv, test_display_svc, &sid);
    731752        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    732753
    … …  
    766787        display_window_destroy(wnd);
    767788        display_close(disp);
    768         rc = loc_service_unregister(sid);
    769         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     789        rc = loc_service_unregister(srv, sid);
     790        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     791        loc_server_unregister(srv);
    770792}
    771793
    … …  
    780802        gfx_rect_t rect;
    781803        test_response_t resp;
    782 
    783         async_set_fallback_port_handler(test_display_conn, &resp);
    784 
    785         // FIXME This causes this test to be non-reentrant!
    786         rc = loc_server_register(test_display_server);
    787         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    788 
    789         rc = loc_service_register(test_display_svc, &sid);
     804        loc_srv_t *srv;
     805
     806        async_set_fallback_port_handler(test_display_conn, &resp);
     807
     808        // FIXME This causes this test to be non-reentrant!
     809        rc = loc_server_register(test_display_server, &srv);
     810        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     811
     812        rc = loc_service_register(srv, test_display_svc, &sid);
    790813        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    791814
    … …  
    829852        display_window_destroy(wnd);
    830853        display_close(disp);
    831         rc = loc_service_unregister(sid);
    832         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     854        rc = loc_service_unregister(srv, sid);
     855        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     856        loc_server_unregister(srv);
    833857}
    834858
    … …  
    845869        gfx_coord2_t pos;
    846870        sysarg_t pos_id;
    847 
    848         async_set_fallback_port_handler(test_display_conn, &resp);
    849 
    850         // FIXME This causes this test to be non-reentrant!
    851         rc = loc_server_register(test_display_server);
    852         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    853 
    854         rc = loc_service_register(test_display_svc, &sid);
     871        loc_srv_t *srv;
     872
     873        async_set_fallback_port_handler(test_display_conn, &resp);
     874
     875        // FIXME This causes this test to be non-reentrant!
     876        rc = loc_server_register(test_display_server, &srv);
     877        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     878
     879        rc = loc_service_register(srv, test_display_svc, &sid);
    855880        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    856881
    … …  
    890915        display_window_destroy(wnd);
    891916        display_close(disp);
    892         rc = loc_service_unregister(sid);
    893         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     917        rc = loc_service_unregister(srv, sid);
     918        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     919        loc_server_unregister(srv);
    894920}
    895921
    … …  
    906932        gfx_coord2_t pos;
    907933        sysarg_t pos_id;
    908 
    909         async_set_fallback_port_handler(test_display_conn, &resp);
    910 
    911         // FIXME This causes this test to be non-reentrant!
    912         rc = loc_server_register(test_display_server);
    913         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    914 
    915         rc = loc_service_register(test_display_svc, &sid);
     934        loc_srv_t *srv;
     935
     936        async_set_fallback_port_handler(test_display_conn, &resp);
     937
     938        // FIXME This causes this test to be non-reentrant!
     939        rc = loc_server_register(test_display_server, &srv);
     940        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     941
     942        rc = loc_service_register(srv, test_display_svc, &sid);
    916943        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    917944
    … …  
    951978        display_window_destroy(wnd);
    952979        display_close(disp);
    953         rc = loc_service_unregister(sid);
    954         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     980        rc = loc_service_unregister(srv, sid);
     981        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     982        loc_server_unregister(srv);
    955983}
    956984
    … …  
    966994        gfx_rect_t nrect;
    967995        test_response_t resp;
    968 
    969         async_set_fallback_port_handler(test_display_conn, &resp);
    970 
    971         // FIXME This causes this test to be non-reentrant!
    972         rc = loc_server_register(test_display_server);
    973         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    974 
    975         rc = loc_service_register(test_display_svc, &sid);
     996        loc_srv_t *srv;
     997
     998        async_set_fallback_port_handler(test_display_conn, &resp);
     999
     1000        // FIXME This causes this test to be non-reentrant!
     1001        rc = loc_server_register(test_display_server, &srv);
     1002        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1003
     1004        rc = loc_service_register(srv, test_display_svc, &sid);
    9761005        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9771006
    … …  
    10141043        display_window_destroy(wnd);
    10151044        display_close(disp);
    1016         rc = loc_service_unregister(sid);
    1017         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1045        rc = loc_service_unregister(srv, sid);
     1046        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1047        loc_server_unregister(srv);
    10181048}
    10191049
    … …  
    10291059        gfx_rect_t nrect;
    10301060        test_response_t resp;
    1031 
    1032         async_set_fallback_port_handler(test_display_conn, &resp);
    1033 
    1034         // FIXME This causes this test to be non-reentrant!
    1035         rc = loc_server_register(test_display_server);
    1036         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1037 
    1038         rc = loc_service_register(test_display_svc, &sid);
     1061        loc_srv_t *srv;
     1062
     1063        async_set_fallback_port_handler(test_display_conn, &resp);
     1064
     1065        // FIXME This causes this test to be non-reentrant!
     1066        rc = loc_server_register(test_display_server, &srv);
     1067        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1068
     1069        rc = loc_service_register(srv, test_display_svc, &sid);
    10391070        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10401071
    … …  
    10761107        display_window_destroy(wnd);
    10771108        display_close(disp);
    1078         rc = loc_service_unregister(sid);
    1079         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1109        rc = loc_service_unregister(srv, sid);
     1110        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1111        loc_server_unregister(srv);
    10801112}
    10811113
    … …  
    10891121        display_window_t *wnd;
    10901122        test_response_t resp;
    1091 
    1092         async_set_fallback_port_handler(test_display_conn, &resp);
    1093 
    1094         // FIXME This causes this test to be non-reentrant!
    1095         rc = loc_server_register(test_display_server);
    1096         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1097 
    1098         rc = loc_service_register(test_display_svc, &sid);
     1123        loc_srv_t *srv;
     1124
     1125        async_set_fallback_port_handler(test_display_conn, &resp);
     1126
     1127        // FIXME This causes this test to be non-reentrant!
     1128        rc = loc_server_register(test_display_server, &srv);
     1129        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1130
     1131        rc = loc_service_register(srv, test_display_svc, &sid);
    10991132        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    11001133
    … …  
    11241157        display_window_destroy(wnd);
    11251158        display_close(disp);
    1126         rc = loc_service_unregister(sid);
    1127         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1159        rc = loc_service_unregister(srv, sid);
     1160        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1161        loc_server_unregister(srv);
    11281162}
    11291163
    … …  
    11371171        display_window_t *wnd;
    11381172        test_response_t resp;
    1139 
    1140         async_set_fallback_port_handler(test_display_conn, &resp);
    1141 
    1142         // FIXME This causes this test to be non-reentrant!
    1143         rc = loc_server_register(test_display_server);
    1144         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1145 
    1146         rc = loc_service_register(test_display_svc, &sid);
     1173        loc_srv_t *srv;
     1174
     1175        async_set_fallback_port_handler(test_display_conn, &resp);
     1176
     1177        // FIXME This causes this test to be non-reentrant!
     1178        rc = loc_server_register(test_display_server, &srv);
     1179        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1180
     1181        rc = loc_service_register(srv, test_display_svc, &sid);
    11471182        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    11481183
    … …  
    11721207        display_window_destroy(wnd);
    11731208        display_close(disp);
    1174         rc = loc_service_unregister(sid);
    1175         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1209        rc = loc_service_unregister(srv, sid);
     1210        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1211        loc_server_unregister(srv);
    11761212}
    11771213
    … …  
    11851221        display_window_t *wnd;
    11861222        test_response_t resp;
    1187 
    1188         async_set_fallback_port_handler(test_display_conn, &resp);
    1189 
    1190         // FIXME This causes this test to be non-reentrant!
    1191         rc = loc_server_register(test_display_server);
    1192         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1193 
    1194         rc = loc_service_register(test_display_svc, &sid);
     1223        loc_srv_t *srv;
     1224
     1225        async_set_fallback_port_handler(test_display_conn, &resp);
     1226
     1227        // FIXME This causes this test to be non-reentrant!
     1228        rc = loc_server_register(test_display_server, &srv);
     1229        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1230
     1231        rc = loc_service_register(srv, test_display_svc, &sid);
    11951232        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    11961233
    … …  
    12201257        display_window_destroy(wnd);
    12211258        display_close(disp);
    1222         rc = loc_service_unregister(sid);
    1223         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1259        rc = loc_service_unregister(srv, sid);
     1260        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1261        loc_server_unregister(srv);
    12241262}
    12251263
    … …  
    12331271        display_window_t *wnd;
    12341272        test_response_t resp;
    1235 
    1236         async_set_fallback_port_handler(test_display_conn, &resp);
    1237 
    1238         // FIXME This causes this test to be non-reentrant!
    1239         rc = loc_server_register(test_display_server);
    1240         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1241 
    1242         rc = loc_service_register(test_display_svc, &sid);
     1273        loc_srv_t *srv;
     1274
     1275        async_set_fallback_port_handler(test_display_conn, &resp);
     1276
     1277        // FIXME This causes this test to be non-reentrant!
     1278        rc = loc_server_register(test_display_server, &srv);
     1279        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1280
     1281        rc = loc_service_register(srv, test_display_svc, &sid);
    12431282        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    12441283
    … …  
    12681307        display_window_destroy(wnd);
    12691308        display_close(disp);
    1270         rc = loc_service_unregister(sid);
    1271         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1309        rc = loc_service_unregister(srv, sid);
     1310        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1311        loc_server_unregister(srv);
    12721312}
    12731313
    … …  
    12811321        display_window_t *wnd;
    12821322        test_response_t resp;
    1283 
    1284         async_set_fallback_port_handler(test_display_conn, &resp);
    1285 
    1286         // FIXME This causes this test to be non-reentrant!
    1287         rc = loc_server_register(test_display_server);
    1288         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1289 
    1290         rc = loc_service_register(test_display_svc, &sid);
     1323        loc_srv_t *srv;
     1324
     1325        async_set_fallback_port_handler(test_display_conn, &resp);
     1326
     1327        // FIXME This causes this test to be non-reentrant!
     1328        rc = loc_server_register(test_display_server, &srv);
     1329        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1330
     1331        rc = loc_service_register(srv, test_display_svc, &sid);
    12911332        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    12921333
    … …  
    13181359        display_window_destroy(wnd);
    13191360        display_close(disp);
    1320         rc = loc_service_unregister(sid);
    1321         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1361        rc = loc_service_unregister(srv, sid);
     1362        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1363        loc_server_unregister(srv);
    13221364}
    13231365
    … …  
    13311373        display_window_t *wnd;
    13321374        test_response_t resp;
    1333 
    1334         async_set_fallback_port_handler(test_display_conn, &resp);
    1335 
    1336         // FIXME This causes this test to be non-reentrant!
    1337         rc = loc_server_register(test_display_server);
    1338         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1339 
    1340         rc = loc_service_register(test_display_svc, &sid);
     1375        loc_srv_t *srv;
     1376
     1377        async_set_fallback_port_handler(test_display_conn, &resp);
     1378
     1379        // FIXME This causes this test to be non-reentrant!
     1380        rc = loc_server_register(test_display_server, &srv);
     1381        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1382
     1383        rc = loc_service_register(srv, test_display_svc, &sid);
    13411384        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    13421385
    … …  
    13681411        display_window_destroy(wnd);
    13691412        display_close(disp);
    1370         rc = loc_service_unregister(sid);
    1371         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1413        rc = loc_service_unregister(srv, sid);
     1414        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1415        loc_server_unregister(srv);
    13721416}
    13731417
    … …  
    13821426        const char *caption;
    13831427        test_response_t resp;
    1384 
    1385         async_set_fallback_port_handler(test_display_conn, &resp);
    1386 
    1387         // FIXME This causes this test to be non-reentrant!
    1388         rc = loc_server_register(test_display_server);
    1389         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1390 
    1391         rc = loc_service_register(test_display_svc, &sid);
     1428        loc_srv_t *srv;
     1429
     1430        async_set_fallback_port_handler(test_display_conn, &resp);
     1431
     1432        // FIXME This causes this test to be non-reentrant!
     1433        rc = loc_server_register(test_display_server, &srv);
     1434        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1435
     1436        rc = loc_service_register(srv, test_display_svc, &sid);
    13921437        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    13931438
    … …  
    14221467        display_window_destroy(wnd);
    14231468        display_close(disp);
    1424         rc = loc_service_unregister(sid);
    1425         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1469        rc = loc_service_unregister(srv, sid);
     1470        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1471        loc_server_unregister(srv);
    14261472}
    14271473
    … …  
    14361482        const char *caption;
    14371483        test_response_t resp;
    1438 
    1439         async_set_fallback_port_handler(test_display_conn, &resp);
    1440 
    1441         // FIXME This causes this test to be non-reentrant!
    1442         rc = loc_server_register(test_display_server);
    1443         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1444 
    1445         rc = loc_service_register(test_display_svc, &sid);
     1484        loc_srv_t *srv;
     1485
     1486        async_set_fallback_port_handler(test_display_conn, &resp);
     1487
     1488        // FIXME This causes this test to be non-reentrant!
     1489        rc = loc_server_register(test_display_server, &srv);
     1490        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1491
     1492        rc = loc_service_register(srv, test_display_svc, &sid);
    14461493        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    14471494
    … …  
    14761523        display_window_destroy(wnd);
    14771524        display_close(disp);
    1478         rc = loc_service_unregister(sid);
    1479         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1525        rc = loc_service_unregister(srv, sid);
     1526        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1527        loc_server_unregister(srv);
    14801528}
    14811529
    … …  
    14901538        test_response_t resp;
    14911539        gfx_context_t *gc;
    1492 
    1493         async_set_fallback_port_handler(test_display_conn, &resp);
    1494 
    1495         // FIXME This causes this test to be non-reentrant!
    1496         rc = loc_server_register(test_display_server);
    1497         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1498 
    1499         rc = loc_service_register(test_display_svc, &sid);
     1540        loc_srv_t *srv;
     1541
     1542        async_set_fallback_port_handler(test_display_conn, &resp);
     1543
     1544        // FIXME This causes this test to be non-reentrant!
     1545        rc = loc_server_register(test_display_server, &srv);
     1546        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1547
     1548        rc = loc_service_register(srv, test_display_svc, &sid);
    15001549        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    15011550
    … …  
    15281577
    15291578        display_close(disp);
    1530         rc = loc_service_unregister(sid);
    1531         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1579        rc = loc_service_unregister(srv, sid);
     1580        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1581        loc_server_unregister(srv);
    15321582}
    15331583
    … …  
    15431593        gfx_context_t *gc;
    15441594        gfx_color_t *color;
    1545 
    1546         async_set_fallback_port_handler(test_display_conn, &resp);
    1547 
    1548         // FIXME This causes this test to be non-reentrant!
    1549         rc = loc_server_register(test_display_server);
    1550         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1551 
    1552         rc = loc_service_register(test_display_svc, &sid);
     1595        loc_srv_t *srv;
     1596
     1597        async_set_fallback_port_handler(test_display_conn, &resp);
     1598
     1599        // FIXME This causes this test to be non-reentrant!
     1600        rc = loc_server_register(test_display_server, &srv);
     1601        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1602
     1603        rc = loc_service_register(srv, test_display_svc, &sid);
    15531604        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    15541605
    … …  
    15891640
    15901641        display_close(disp);
    1591         rc = loc_service_unregister(sid);
    1592         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1642        rc = loc_service_unregister(srv, sid);
     1643        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1644        loc_server_unregister(srv);
    15931645}
    15941646
    … …  
    16021654        display_window_t *wnd;
    16031655        test_response_t resp;
    1604 
    1605         async_set_fallback_port_handler(test_display_conn, &resp);
    1606 
    1607         // FIXME This causes this test to be non-reentrant!
    1608         rc = loc_server_register(test_display_server);
    1609         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1610 
    1611         rc = loc_service_register(test_display_svc, &sid);
     1656        loc_srv_t *srv;
     1657
     1658        async_set_fallback_port_handler(test_display_conn, &resp);
     1659
     1660        // FIXME This causes this test to be non-reentrant!
     1661        rc = loc_server_register(test_display_server, &srv);
     1662        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1663
     1664        rc = loc_service_register(srv, test_display_svc, &sid);
    16121665        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16131666
    … …  
    16541707        display_close(disp);
    16551708
    1656         rc = loc_service_unregister(sid);
    1657         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1709        rc = loc_service_unregister(srv, sid);
     1710        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1711        loc_server_unregister(srv);
    16581712}
    16591713
    … …  
    16671721        display_window_t *wnd;
    16681722        test_response_t resp;
    1669 
    1670         async_set_fallback_port_handler(test_display_conn, &resp);
    1671 
    1672         // FIXME This causes this test to be non-reentrant!
    1673         rc = loc_server_register(test_display_server);
    1674         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1675 
    1676         rc = loc_service_register(test_display_svc, &sid);
     1723        loc_srv_t *srv;
     1724
     1725        async_set_fallback_port_handler(test_display_conn, &resp);
     1726
     1727        // FIXME This causes this test to be non-reentrant!
     1728        rc = loc_server_register(test_display_server, &srv);
     1729        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1730
     1731        rc = loc_service_register(srv, test_display_svc, &sid);
    16771732        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16781733
    … …  
    17221777        display_close(disp);
    17231778
    1724         rc = loc_service_unregister(sid);
    1725         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1779        rc = loc_service_unregister(srv, sid);
     1780        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1781        loc_server_unregister(srv);
    17261782}
    17271783
    … …  
    17351791        display_window_t *wnd;
    17361792        test_response_t resp;
    1737 
    1738         async_set_fallback_port_handler(test_display_conn, &resp);
    1739 
    1740         // FIXME This causes this test to be non-reentrant!
    1741         rc = loc_server_register(test_display_server);
    1742         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1743 
    1744         rc = loc_service_register(test_display_svc, &sid);
     1793        loc_srv_t *srv;
     1794
     1795        async_set_fallback_port_handler(test_display_conn, &resp);
     1796
     1797        // FIXME This causes this test to be non-reentrant!
     1798        rc = loc_server_register(test_display_server, &srv);
     1799        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1800
     1801        rc = loc_service_register(srv, test_display_svc, &sid);
    17451802        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    17461803
    … …  
    17991856        display_close(disp);
    18001857
    1801         rc = loc_service_unregister(sid);
    1802         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1858        rc = loc_service_unregister(srv, sid);
     1859        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1860        loc_server_unregister(srv);
    18031861}
    18041862
    … …  
    18121870        display_window_t *wnd;
    18131871        test_response_t resp;
    1814 
    1815         async_set_fallback_port_handler(test_display_conn, &resp);
    1816 
    1817         // FIXME This causes this test to be non-reentrant!
    1818         rc = loc_server_register(test_display_server);
    1819         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1820 
    1821         rc = loc_service_register(test_display_svc, &sid);
     1872        loc_srv_t *srv;
     1873
     1874        async_set_fallback_port_handler(test_display_conn, &resp);
     1875
     1876        // FIXME This causes this test to be non-reentrant!
     1877        rc = loc_server_register(test_display_server, &srv);
     1878        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1879
     1880        rc = loc_service_register(srv, test_display_svc, &sid);
    18221881        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18231882
    … …  
    18761935        display_close(disp);
    18771936
    1878         rc = loc_service_unregister(sid);
    1879         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1937        rc = loc_service_unregister(srv, sid);
     1938        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1939        loc_server_unregister(srv);
    18801940}
    18811941
    … …  
    18891949        display_window_t *wnd;
    18901950        test_response_t resp;
    1891 
    1892         async_set_fallback_port_handler(test_display_conn, &resp);
    1893 
    1894         // FIXME This causes this test to be non-reentrant!
    1895         rc = loc_server_register(test_display_server);
    1896         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1897 
    1898         rc = loc_service_register(test_display_svc, &sid);
     1951        loc_srv_t *srv;
     1952
     1953        async_set_fallback_port_handler(test_display_conn, &resp);
     1954
     1955        // FIXME This causes this test to be non-reentrant!
     1956        rc = loc_server_register(test_display_server, &srv);
     1957        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1958
     1959        rc = loc_service_register(srv, test_display_svc, &sid);
    18991960        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19001961
    … …  
    19442005        display_close(disp);
    19452006
    1946         rc = loc_service_unregister(sid);
    1947         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2007        rc = loc_service_unregister(srv, sid);
     2008        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2009        loc_server_unregister(srv);
    19482010}
    19492011
    … …  
    19562018        display_info_t info;
    19572019        test_response_t resp;
    1958 
    1959         async_set_fallback_port_handler(test_display_conn, &resp);
    1960 
    1961         // FIXME This causes this test to be non-reentrant!
    1962         rc = loc_server_register(test_display_server);
    1963         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1964 
    1965         rc = loc_service_register(test_display_svc, &sid);
     2020        loc_srv_t *srv;
     2021
     2022        async_set_fallback_port_handler(test_display_conn, &resp);
     2023
     2024        // FIXME This causes this test to be non-reentrant!
     2025        rc = loc_server_register(test_display_server, &srv);
     2026        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2027
     2028        rc = loc_service_register(srv, test_display_svc, &sid);
    19662029        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19672030
    … …  
    19782041
    19792042        display_close(disp);
    1980         rc = loc_service_unregister(sid);
    1981         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2043        rc = loc_service_unregister(srv, sid);
     2044        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2045        loc_server_unregister(srv);
    19822046}
    19832047
    … …  
    19902054        display_info_t info;
    19912055        test_response_t resp;
    1992 
    1993         async_set_fallback_port_handler(test_display_conn, &resp);
    1994 
    1995         // FIXME This causes this test to be non-reentrant!
    1996         rc = loc_server_register(test_display_server);
    1997         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1998 
    1999         rc = loc_service_register(test_display_svc, &sid);
     2056        loc_srv_t *srv;
     2057
     2058        async_set_fallback_port_handler(test_display_conn, &resp);
     2059
     2060        // FIXME This causes this test to be non-reentrant!
     2061        rc = loc_server_register(test_display_server, &srv);
     2062        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2063
     2064        rc = loc_service_register(srv, test_display_svc, &sid);
    20002065        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20012066
    … …  
    20202085
    20212086        display_close(disp);
    2022         rc = loc_service_unregister(sid);
    2023         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2087        rc = loc_service_unregister(srv, sid);
     2088        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2089        loc_server_unregister(srv);
    20242090}
    20252091

  • uspace/lib/hound/src/protocol.c

    r6a0b2cc r4c6fd56  
    11/*
     2 * Copyright (c) 2023 Jiri Svoboda
    23 * Copyright (c) 2012 Jan Vesely
    34 * All rights reserved.
    … …  
    8485const char *HOUND_SERVICE = "audio/hound";
    8586
     87/** Server object */
     88static loc_srv_t *hound_srv;
     89
    8690/**
    8791 * Start a new audio session.
    … …  
    730734errno_t hound_server_register(const char *name, service_id_t *id)
    731735{
     736        errno_t rc;
     737
    732738        if (!name || !id)
    733739                return EINVAL;
    734740
    735         errno_t ret = loc_server_register(name);
    736         if (ret != EOK)
    737                 return ret;
    738 
    739         return loc_service_register(HOUND_SERVICE, id);
     741        if (hound_srv != NULL)
     742                return EBUSY;
     743
     744        rc = loc_server_register(name, &hound_srv);
     745        if (rc != EOK)
     746                return rc;
     747
     748        rc = loc_service_register(hound_srv, HOUND_SERVICE, id);
     749        if (rc != EOK) {
     750                loc_server_unregister(hound_srv);
     751                return rc;
     752        }
     753
     754        return EOK;
    740755}
    741756
    … …  
    746761void hound_server_unregister(service_id_t id)
    747762{
    748         loc_service_unregister(id);
     763        loc_service_unregister(hound_srv, id);
     764        loc_server_unregister(hound_srv);
    749765}
    750766

  • uspace/lib/ipcgfx/test/ipcgfx.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2021 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    120120        async_sess_t *sess;
    121121        ipc_gc_t *ipcgc;
    122 
    123         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    124 
    125         // FIXME This causes this test to be non-reentrant!
    126         rc = loc_server_register(test_ipcgfx_server);
    127         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    128 
    129         rc = loc_service_register(test_ipcgfx_svc, &sid);
     122        loc_srv_t *srv;
     123
     124        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     125
     126        // FIXME This causes this test to be non-reentrant!
     127        rc = loc_server_register(test_ipcgfx_server, &srv);
     128        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     129
     130        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    130131        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    131132
    … …  
    156157        async_hangup(sess);
    157158
    158         rc = loc_service_unregister(sid);
    159         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     159        rc = loc_service_unregister(srv, sid);
     160        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     161        loc_server_unregister(srv);
    160162}
    161163
    … …  
    170172        async_sess_t *sess;
    171173        ipc_gc_t *ipcgc;
    172 
    173         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    174 
    175         // FIXME This causes this test to be non-reentrant!
    176         rc = loc_server_register(test_ipcgfx_server);
    177         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    178 
    179         rc = loc_service_register(test_ipcgfx_svc, &sid);
     174        loc_srv_t *srv;
     175
     176        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     177
     178        // FIXME This causes this test to be non-reentrant!
     179        rc = loc_server_register(test_ipcgfx_server, &srv);
     180        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     181
     182        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    180183        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    181184
    … …  
    207210        async_hangup(sess);
    208211
    209         rc = loc_service_unregister(sid);
    210         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     212        rc = loc_service_unregister(srv, sid);
     213        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     214        loc_server_unregister(srv);
    211215}
    212216
    … …  
    220224        async_sess_t *sess;
    221225        ipc_gc_t *ipcgc;
    222 
    223         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    224 
    225         // FIXME This causes this test to be non-reentrant!
    226         rc = loc_server_register(test_ipcgfx_server);
    227         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    228 
    229         rc = loc_service_register(test_ipcgfx_svc, &sid);
     226        loc_srv_t *srv;
     227
     228        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     229
     230        // FIXME This causes this test to be non-reentrant!
     231        rc = loc_server_register(test_ipcgfx_server, &srv);
     232        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     233
     234        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    230235        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    231236
    … …  
    250255        async_hangup(sess);
    251256
    252         rc = loc_service_unregister(sid);
    253         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     257        rc = loc_service_unregister(srv, sid);
     258        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     259        loc_server_unregister(srv);
    254260}
    255261
    … …  
    264270        async_sess_t *sess;
    265271        ipc_gc_t *ipcgc;
    266 
    267         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    268 
    269         // FIXME This causes this test to be non-reentrant!
    270         rc = loc_server_register(test_ipcgfx_server);
    271         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    272 
    273         rc = loc_service_register(test_ipcgfx_svc, &sid);
     272        loc_srv_t *srv;
     273
     274        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     275
     276        // FIXME This causes this test to be non-reentrant!
     277        rc = loc_server_register(test_ipcgfx_server, &srv);
     278        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     279
     280        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    274281        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    275282
    … …  
    300307        async_hangup(sess);
    301308
    302         rc = loc_service_unregister(sid);
    303         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     309        rc = loc_service_unregister(srv, sid);
     310        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     311        loc_server_unregister(srv);
    304312}
    305313
    … …  
    314322        async_sess_t *sess;
    315323        ipc_gc_t *ipcgc;
    316 
    317         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    318 
    319         // FIXME This causes this test to be non-reentrant!
    320         rc = loc_server_register(test_ipcgfx_server);
    321         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    322 
    323         rc = loc_service_register(test_ipcgfx_svc, &sid);
     324        loc_srv_t *srv;
     325
     326        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     327
     328        // FIXME This causes this test to be non-reentrant!
     329        rc = loc_server_register(test_ipcgfx_server, &srv);
     330        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     331
     332        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    324333        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    325334
    … …  
    350359        async_hangup(sess);
    351360
    352         rc = loc_service_unregister(sid);
    353         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     361        rc = loc_service_unregister(srv, sid);
     362        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     363        loc_server_unregister(srv);
    354364}
    355365
    … …  
    364374        async_sess_t *sess;
    365375        ipc_gc_t *ipcgc;
    366 
    367         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    368 
    369         // FIXME This causes this test to be non-reentrant!
    370         rc = loc_server_register(test_ipcgfx_server);
    371         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    372 
    373         rc = loc_service_register(test_ipcgfx_svc, &sid);
     376        loc_srv_t *srv;
     377
     378        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     379
     380        // FIXME This causes this test to be non-reentrant!
     381        rc = loc_server_register(test_ipcgfx_server, &srv);
     382        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     383
     384        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    374385        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    375386
    … …  
    400411        async_hangup(sess);
    401412
    402         rc = loc_service_unregister(sid);
    403         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     413        rc = loc_service_unregister(srv, sid);
     414        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     415        loc_server_unregister(srv);
    404416}
    405417
    … …  
    414426        async_sess_t *sess;
    415427        ipc_gc_t *ipcgc;
    416 
    417         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    418 
    419         // FIXME This causes this test to be non-reentrant!
    420         rc = loc_server_register(test_ipcgfx_server);
    421         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    422 
    423         rc = loc_service_register(test_ipcgfx_svc, &sid);
     428        loc_srv_t *srv;
     429
     430        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     431
     432        // FIXME This causes this test to be non-reentrant!
     433        rc = loc_server_register(test_ipcgfx_server, &srv);
     434        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     435
     436        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    424437        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    425438
    … …  
    450463        async_hangup(sess);
    451464
    452         rc = loc_service_unregister(sid);
    453         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     465        rc = loc_service_unregister(srv, sid);
     466        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     467        loc_server_unregister(srv);
    454468}
    455469
    … …  
    463477        async_sess_t *sess;
    464478        ipc_gc_t *ipcgc;
    465 
    466         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    467 
    468         // FIXME This causes this test to be non-reentrant!
    469         rc = loc_server_register(test_ipcgfx_server);
    470         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    471 
    472         rc = loc_service_register(test_ipcgfx_svc, &sid);
     479        loc_srv_t *srv;
     480
     481        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     482
     483        // FIXME This causes this test to be non-reentrant!
     484        rc = loc_server_register(test_ipcgfx_server, &srv);
     485        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     486
     487        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    473488        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    474489
    … …  
    491506        async_hangup(sess);
    492507
    493         rc = loc_service_unregister(sid);
    494         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     508        rc = loc_service_unregister(srv, sid);
     509        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     510        loc_server_unregister(srv);
    495511}
    496512
    … …  
    504520        async_sess_t *sess;
    505521        ipc_gc_t *ipcgc;
    506 
    507         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    508 
    509         // FIXME This causes this test to be non-reentrant!
    510         rc = loc_server_register(test_ipcgfx_server);
    511         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    512 
    513         rc = loc_service_register(test_ipcgfx_svc, &sid);
     522        loc_srv_t *srv;
     523
     524        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     525
     526        // FIXME This causes this test to be non-reentrant!
     527        rc = loc_server_register(test_ipcgfx_server, &srv);
     528        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     529
     530        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    514531        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    515532
    … …  
    532549        async_hangup(sess);
    533550
    534         rc = loc_service_unregister(sid);
    535         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     551        rc = loc_service_unregister(srv, sid);
     552        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     553        loc_server_unregister(srv);
    536554}
    537555
    … …  
    547565        async_sess_t *sess;
    548566        ipc_gc_t *ipcgc;
    549 
    550         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    551 
    552         // FIXME This causes this test to be non-reentrant!
    553         rc = loc_server_register(test_ipcgfx_server);
    554         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    555 
    556         rc = loc_service_register(test_ipcgfx_svc, &sid);
     567        loc_srv_t *srv;
     568
     569        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     570
     571        // FIXME This causes this test to be non-reentrant!
     572        rc = loc_server_register(test_ipcgfx_server, &srv);
     573        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     574
     575        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    557576        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    558577
    … …  
    591610        async_hangup(sess);
    592611
    593         rc = loc_service_unregister(sid);
    594         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     612        rc = loc_service_unregister(srv, sid);
     613        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     614        loc_server_unregister(srv);
    595615}
    596616
    … …  
    606626        async_sess_t *sess;
    607627        ipc_gc_t *ipcgc;
    608 
    609         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    610 
    611         // FIXME This causes this test to be non-reentrant!
    612         rc = loc_server_register(test_ipcgfx_server);
    613         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    614 
    615         rc = loc_service_register(test_ipcgfx_svc, &sid);
     628        loc_srv_t *srv;
     629
     630        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     631
     632        // FIXME This causes this test to be non-reentrant!
     633        rc = loc_server_register(test_ipcgfx_server, &srv);
     634        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     635
     636        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    616637        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    617638
    … …  
    655676        async_hangup(sess);
    656677
    657         rc = loc_service_unregister(sid);
    658         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     678        rc = loc_service_unregister(srv, sid);
     679        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     680        loc_server_unregister(srv);
    659681}
    660682
    … …  
    670692        async_sess_t *sess;
    671693        ipc_gc_t *ipcgc;
    672 
    673         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    674 
    675         // FIXME This causes this test to be non-reentrant!
    676         rc = loc_server_register(test_ipcgfx_server);
    677         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    678 
    679         rc = loc_service_register(test_ipcgfx_svc, &sid);
     694        loc_srv_t *srv;
     695
     696        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     697
     698        // FIXME This causes this test to be non-reentrant!
     699        rc = loc_server_register(test_ipcgfx_server, &srv);
     700        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     701
     702        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    680703        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    681704
    … …  
    708731        async_hangup(sess);
    709732
    710         rc = loc_service_unregister(sid);
    711         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     733        rc = loc_service_unregister(srv, sid);
     734        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     735        loc_server_unregister(srv);
    712736}
    713737
    … …  
    723747        async_sess_t *sess;
    724748        ipc_gc_t *ipcgc;
    725 
    726         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    727 
    728         // FIXME This causes this test to be non-reentrant!
    729         rc = loc_server_register(test_ipcgfx_server);
    730         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    731 
    732         rc = loc_service_register(test_ipcgfx_svc, &sid);
     749        loc_srv_t *srv;
     750
     751        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     752
     753        // FIXME This causes this test to be non-reentrant!
     754        rc = loc_server_register(test_ipcgfx_server, &srv);
     755        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     756
     757        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    733758        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    734759
    … …  
    768793        async_hangup(sess);
    769794
    770         rc = loc_service_unregister(sid);
    771         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     795        rc = loc_service_unregister(srv, sid);
     796        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     797        loc_server_unregister(srv);
    772798}
    773799
    … …  
    783809        async_sess_t *sess;
    784810        ipc_gc_t *ipcgc;
    785 
    786         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    787 
    788         // FIXME This causes this test to be non-reentrant!
    789         rc = loc_server_register(test_ipcgfx_server);
    790         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    791 
    792         rc = loc_service_register(test_ipcgfx_svc, &sid);
     811        loc_srv_t *srv;
     812
     813        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     814
     815        // FIXME This causes this test to be non-reentrant!
     816        rc = loc_server_register(test_ipcgfx_server, &srv);
     817        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     818
     819        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    793820        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    794821
    … …  
    833860        async_hangup(sess);
    834861
    835         rc = loc_service_unregister(sid);
    836         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     862        rc = loc_service_unregister(srv, sid);
     863        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     864        loc_server_unregister(srv);
    837865}
    838866
    … …  
    850878        async_sess_t *sess;
    851879        ipc_gc_t *ipcgc;
    852 
    853         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    854 
    855         // FIXME This causes this test to be non-reentrant!
    856         rc = loc_server_register(test_ipcgfx_server);
    857         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    858 
    859         rc = loc_service_register(test_ipcgfx_svc, &sid);
     880        loc_srv_t *srv;
     881
     882        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     883
     884        // FIXME This causes this test to be non-reentrant!
     885        rc = loc_server_register(test_ipcgfx_server, &srv);
     886        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     887
     888        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    860889        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    861890
    … …  
    901930        async_hangup(sess);
    902931
    903         rc = loc_service_unregister(sid);
    904         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     932        rc = loc_service_unregister(srv, sid);
     933        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     934        loc_server_unregister(srv);
    905935}
    906936
    … …  
    918948        async_sess_t *sess;
    919949        ipc_gc_t *ipcgc;
    920 
    921         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    922 
    923         // FIXME This causes this test to be non-reentrant!
    924         rc = loc_server_register(test_ipcgfx_server);
    925         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    926 
    927         rc = loc_service_register(test_ipcgfx_svc, &sid);
     950        loc_srv_t *srv;
     951
     952        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     953
     954        // FIXME This causes this test to be non-reentrant!
     955        rc = loc_server_register(test_ipcgfx_server, &srv);
     956        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     957
     958        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    928959        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    929960
    … …  
    9691000        async_hangup(sess);
    9701001
    971         rc = loc_service_unregister(sid);
    972         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1002        rc = loc_service_unregister(srv, sid);
     1003        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1004        loc_server_unregister(srv);
    9731005}
    9741006
    … …  
    9851017        async_sess_t *sess;
    9861018        ipc_gc_t *ipcgc;
    987 
    988         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    989 
    990         // FIXME This causes this test to be non-reentrant!
    991         rc = loc_server_register(test_ipcgfx_server);
    992         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    993 
    994         rc = loc_service_register(test_ipcgfx_svc, &sid);
     1019        loc_srv_t *srv;
     1020
     1021        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     1022
     1023        // FIXME This causes this test to be non-reentrant!
     1024        rc = loc_server_register(test_ipcgfx_server, &srv);
     1025        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1026
     1027        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    9951028        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9961029
    … …  
    10291062        async_hangup(sess);
    10301063
    1031         rc = loc_service_unregister(sid);
    1032         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1064        rc = loc_service_unregister(srv, sid);
     1065        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1066        loc_server_unregister(srv);
    10331067}
    10341068

  • uspace/lib/wndmgt/test/wndmgt.c

    r6a0b2cc r4c6fd56  
    117117        wndmgt_t *wndmgt = NULL;
    118118        test_response_t resp;
    119 
    120         async_set_fallback_port_handler(test_wndmgt_conn, &resp);
    121 
    122         // FIXME This causes this test to be non-reentrant!
    123         rc = loc_server_register(test_wndmgt_server);
    124         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    125 
    126         rc = loc_service_register(test_wndmgt_svc, &sid);
    127         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    128 
    129         rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
    130         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    131         PCUT_ASSERT_NOT_NULL(wndmgt);
    132 
    133         wndmgt_close(wndmgt);
    134         rc = loc_service_unregister(sid);
    135         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     119        loc_srv_t *srv;
     120
     121        async_set_fallback_port_handler(test_wndmgt_conn, &resp);
     122
     123        // FIXME This causes this test to be non-reentrant!
     124        rc = loc_server_register(test_wndmgt_server, &srv);
     125        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     126
     127        rc = loc_service_register(srv, test_wndmgt_svc, &sid);
     128        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     129
     130        rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
     131        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     132        PCUT_ASSERT_NOT_NULL(wndmgt);
     133
     134        wndmgt_close(wndmgt);
     135        rc = loc_service_unregister(srv, sid);
     136        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     137        loc_server_unregister(srv);
    136138}
    137139
    … …  
    144146        wndmgt_window_list_t *list;
    145147        test_response_t resp;
    146 
    147         async_set_fallback_port_handler(test_wndmgt_conn, &resp);
    148 
    149         // FIXME This causes this test to be non-reentrant!
    150         rc = loc_server_register(test_wndmgt_server);
    151         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    152 
    153         rc = loc_service_register(test_wndmgt_svc, &sid);
     148        loc_srv_t *srv;
     149
     150        async_set_fallback_port_handler(test_wndmgt_conn, &resp);
     151
     152        // FIXME This causes this test to be non-reentrant!
     153        rc = loc_server_register(test_wndmgt_server, &srv);
     154        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     155
     156        rc = loc_service_register(srv, test_wndmgt_svc, &sid);
    154157        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    155158
    … …  
    166169
    167170        wndmgt_close(wndmgt);
    168         rc = loc_service_unregister(sid);
    169         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     171        rc = loc_service_unregister(srv, sid);
     172        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     173        loc_server_unregister(srv);
    170174}
    171175
    … …  
    178182        wndmgt_window_list_t *list;
    179183        test_response_t resp;
    180 
    181         async_set_fallback_port_handler(test_wndmgt_conn, &resp);
    182 
    183         // FIXME This causes this test to be non-reentrant!
    184         rc = loc_server_register(test_wndmgt_server);
    185         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    186 
    187         rc = loc_service_register(test_wndmgt_svc, &sid);
     184        loc_srv_t *srv;
     185
     186        async_set_fallback_port_handler(test_wndmgt_conn, &resp);
     187
     188        // FIXME This causes this test to be non-reentrant!
     189        rc = loc_server_register(test_wndmgt_server, &srv);
     190        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     191
     192        rc = loc_service_register(srv, test_wndmgt_svc, &sid);
    188193        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    189194
    … …  
    212217        wndmgt_free_window_list(list);
    213218        wndmgt_close(wndmgt);
    214         rc = loc_service_unregister(sid);
    215         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     219        rc = loc_service_unregister(srv, sid);
     220        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     221        loc_server_unregister(srv);
    216222}
    217223
    … …  
    225231        wndmgt_window_info_t *info;
    226232        test_response_t resp;
    227 
    228         async_set_fallback_port_handler(test_wndmgt_conn, &resp);
    229 
    230         // FIXME This causes this test to be non-reentrant!
    231         rc = loc_server_register(test_wndmgt_server);
    232         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    233 
    234         rc = loc_service_register(test_wndmgt_svc, &sid);
     233        loc_srv_t *srv;
     234
     235        async_set_fallback_port_handler(test_wndmgt_conn, &resp);
     236
     237        // FIXME This causes this test to be non-reentrant!
     238        rc = loc_server_register(test_wndmgt_server, &srv);
     239        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     240
     241        rc = loc_service_register(srv, test_wndmgt_svc, &sid);
    235242        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    236243
    … …  
    249256
    250257        wndmgt_close(wndmgt);
    251         rc = loc_service_unregister(sid);
    252         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     258        rc = loc_service_unregister(srv, sid);
     259        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     260        loc_server_unregister(srv);
    253261}
    254262
    … …  
    262270        wndmgt_window_info_t *info;
    263271        test_response_t resp;
    264 
    265         async_set_fallback_port_handler(test_wndmgt_conn, &resp);
    266 
    267         // FIXME This causes this test to be non-reentrant!
    268         rc = loc_server_register(test_wndmgt_server);
    269         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    270 
    271         rc = loc_service_register(test_wndmgt_svc, &sid);
     272        loc_srv_t *srv;
     273
     274        async_set_fallback_port_handler(test_wndmgt_conn, &resp);
     275
     276        // FIXME This causes this test to be non-reentrant!
     277        rc = loc_server_register(test_wndmgt_server, &srv);
     278        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     279
     280        rc = loc_service_register(srv, test_wndmgt_svc, &sid);
    272281        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    273282
    … …  
    297306        wndmgt_free_window_info(info);
    298307        wndmgt_close(wndmgt);
    299         rc = loc_service_unregister(sid);
    300         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     308        rc = loc_service_unregister(srv, sid);
     309        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     310        loc_server_unregister(srv);
    301311}
    302312
    … …  
    310320        sysarg_t wnd_id;
    311321        test_response_t resp;
    312 
    313         async_set_fallback_port_handler(test_wndmgt_conn, &resp);
    314 
    315         // FIXME This causes this test to be non-reentrant!
    316         rc = loc_server_register(test_wndmgt_server);
    317         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    318 
    319         rc = loc_service_register(test_wndmgt_svc, &sid);
     322        loc_srv_t *srv;
     323
     324        async_set_fallback_port_handler(test_wndmgt_conn, &resp);
     325
     326        // FIXME This causes this test to be non-reentrant!
     327        rc = loc_server_register(test_wndmgt_server, &srv);
     328        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     329
     330        rc = loc_service_register(srv, test_wndmgt_svc, &sid);
    320331        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    321332
    … …  
    336347
    337348        wndmgt_close(wndmgt);
    338         rc = loc_service_unregister(sid);
    339         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     349        rc = loc_service_unregister(srv, sid);
     350        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     351        loc_server_unregister(srv);
    340352}
    341353
    … …  
    349361        sysarg_t wnd_id;
    350362        test_response_t resp;
    351 
    352         async_set_fallback_port_handler(test_wndmgt_conn, &resp);
    353 
    354         // FIXME This causes this test to be non-reentrant!
    355         rc = loc_server_register(test_wndmgt_server);
    356         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    357 
    358         rc = loc_service_register(test_wndmgt_svc, &sid);
     363        loc_srv_t *srv;
     364
     365        async_set_fallback_port_handler(test_wndmgt_conn, &resp);
     366
     367        // FIXME This causes this test to be non-reentrant!
     368        rc = loc_server_register(test_wndmgt_server, &srv);
     369        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     370
     371        rc = loc_service_register(srv, test_wndmgt_svc, &sid);
    359372        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    360373
    … …  
    375388
    376389        wndmgt_close(wndmgt);
    377         rc = loc_service_unregister(sid);
    378         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     390        rc = loc_service_unregister(srv, sid);
     391        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     392        loc_server_unregister(srv);
    379393}
    380394
    … …  
    387401        sysarg_t wnd_id;
    388402        test_response_t resp;
    389 
    390         async_set_fallback_port_handler(test_wndmgt_conn, &resp);
    391 
    392         // FIXME This causes this test to be non-reentrant!
    393         rc = loc_server_register(test_wndmgt_server);
    394         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    395 
    396         rc = loc_service_register(test_wndmgt_svc, &sid);
     403        loc_srv_t *srv;
     404
     405        async_set_fallback_port_handler(test_wndmgt_conn, &resp);
     406
     407        // FIXME This causes this test to be non-reentrant!
     408        rc = loc_server_register(test_wndmgt_server, &srv);
     409        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     410
     411        rc = loc_service_register(srv, test_wndmgt_svc, &sid);
    397412        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    398413
    … …  
    411426
    412427        wndmgt_close(wndmgt);
    413         rc = loc_service_unregister(sid);
    414         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     428        rc = loc_service_unregister(srv, sid);
     429        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     430        loc_server_unregister(srv);
    415431}
    416432
    … …  
    423439        sysarg_t wnd_id;
    424440        test_response_t resp;
    425 
    426         async_set_fallback_port_handler(test_wndmgt_conn, &resp);
    427 
    428         // FIXME This causes this test to be non-reentrant!
    429         rc = loc_server_register(test_wndmgt_server);
    430         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    431 
    432         rc = loc_service_register(test_wndmgt_svc, &sid);
     441        loc_srv_t *srv;
     442
     443        async_set_fallback_port_handler(test_wndmgt_conn, &resp);
     444
     445        // FIXME This causes this test to be non-reentrant!
     446        rc = loc_server_register(test_wndmgt_server, &srv);
     447        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     448
     449        rc = loc_service_register(srv, test_wndmgt_svc, &sid);
    433450        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    434451
    … …  
    447464
    448465        wndmgt_close(wndmgt);
    449         rc = loc_service_unregister(sid);
    450         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     466        rc = loc_service_unregister(srv, sid);
     467        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     468        loc_server_unregister(srv);
    451469}
    452470
    … …  
    458476        wndmgt_t *wndmgt = NULL;
    459477        test_response_t resp;
    460 
    461         async_set_fallback_port_handler(test_wndmgt_conn, &resp);
    462 
    463         // FIXME This causes this test to be non-reentrant!
    464         rc = loc_server_register(test_wndmgt_server);
    465         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    466 
    467         rc = loc_service_register(test_wndmgt_svc, &sid);
     478        loc_srv_t *srv;
     479
     480        async_set_fallback_port_handler(test_wndmgt_conn, &resp);
     481
     482        // FIXME This causes this test to be non-reentrant!
     483        rc = loc_server_register(test_wndmgt_server, &srv);
     484        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     485
     486        rc = loc_service_register(srv, test_wndmgt_svc, &sid);
    468487        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    469488
    … …  
    494513        wndmgt_close(wndmgt);
    495514
    496         rc = loc_service_unregister(sid);
    497         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     515        rc = loc_service_unregister(srv, sid);
     516        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     517        loc_server_unregister(srv);
    498518}
    499519
    … …  
    505525        wndmgt_t *wndmgt = NULL;
    506526        test_response_t resp;
    507 
    508         async_set_fallback_port_handler(test_wndmgt_conn, &resp);
    509 
    510         // FIXME This causes this test to be non-reentrant!
    511         rc = loc_server_register(test_wndmgt_server);
    512         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    513 
    514         rc = loc_service_register(test_wndmgt_svc, &sid);
     527        loc_srv_t *srv;
     528
     529        async_set_fallback_port_handler(test_wndmgt_conn, &resp);
     530
     531        // FIXME This causes this test to be non-reentrant!
     532        rc = loc_server_register(test_wndmgt_server, &srv);
     533        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     534
     535        rc = loc_service_register(srv, test_wndmgt_svc, &sid);
    515536        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    516537
    … …  
    541562        wndmgt_close(wndmgt);
    542563
    543         rc = loc_service_unregister(sid);
    544         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     564        rc = loc_service_unregister(srv, sid);
     565        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     566        loc_server_unregister(srv);
    545567}
    546568
    … …  
    552574        wndmgt_t *wndmgt = NULL;
    553575        test_response_t resp;
    554 
    555         async_set_fallback_port_handler(test_wndmgt_conn, &resp);
    556 
    557         // FIXME This causes this test to be non-reentrant!
    558         rc = loc_server_register(test_wndmgt_server);
    559         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    560 
    561         rc = loc_service_register(test_wndmgt_svc, &sid);
     576        loc_srv_t *srv;
     577
     578        async_set_fallback_port_handler(test_wndmgt_conn, &resp);
     579
     580        // FIXME This causes this test to be non-reentrant!
     581        rc = loc_server_register(test_wndmgt_server, &srv);
     582        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     583
     584        rc = loc_service_register(srv, test_wndmgt_svc, &sid);
    562585        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    563586
    … …  
    588611        wndmgt_close(wndmgt);
    589612
    590         rc = loc_service_unregister(sid);
    591         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     613        rc = loc_service_unregister(srv, sid);
     614        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     615        loc_server_unregister(srv);
    592616}
    593617
Note: See TracChangeset for help on using the changeset viewer.