Changeset ca48672 in mainline for uspace/lib


Ignore:
Timestamp:
2025-06-20T15:18:27Z (5 weeks ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
cb20b05
Parents:
3951046
Message:

loc_service_register() needs to take a port ID argument.

Location:
uspace/lib
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/async/ports.c

    r3951046 rca48672  
    197197}
    198198
     199static bool destroy_if(ht_link_t *link, void *arg)
     200{
     201        port_t *port = (port_t *)arg;
     202
     203        hash_table_remove_item(&port->interface_hash_table, link);
     204        return false;
     205}
     206
     207static void async_delete_port(port_t *port)
     208{
     209        /* Destroy interfaces */
     210        hash_table_apply(&port->interface_hash_table, destroy_if, NULL);
     211
     212        hash_table_destroy(&port->interface_hash_table);
     213        free(port);
     214}
     215
    199216errno_t async_create_port_internal(iface_t iface, async_port_handler_t handler,
    200217    void *data, port_id_t *port_id)
    … …  
    212229        interface = async_new_interface(port, iface, handler, data);
    213230        if (interface == NULL) {
    214                 // XXX delete port
     231                async_delete_port(port);
    215232                fibril_rmutex_unlock(&port_mutex);
    216233                return ENOMEM;
    … …  
    218235
    219236        *port_id = port->id;
     237        fibril_rmutex_unlock(&port_mutex);
     238        return EOK;
     239}
     240
     241errno_t async_port_create_interface(port_id_t port_id, iface_t iface,
     242    async_port_handler_t handler, void *data)
     243{
     244        ht_link_t *link;
     245        port_t *port;
     246        interface_t *interface;
     247
     248        fibril_rmutex_lock(&port_mutex);
     249        link = hash_table_find(&port_hash_table, &port_id);
     250        assert(link != NULL);
     251        port = hash_table_get_inst(link, port_t, link);
     252
     253        interface = async_new_interface(port, iface, handler, data);
     254        if (interface == NULL) {
     255                fibril_rmutex_unlock(&port_mutex);
     256                return ENOMEM;
     257        }
     258
    220259        fibril_rmutex_unlock(&port_mutex);
    221260        return EOK;
    … …  
    306345}
    307346
     347void async_port_destroy(port_id_t port_id)
     348{
     349        ht_link_t *link;
     350        port_t *port;
     351
     352        fibril_rmutex_lock(&port_mutex);
     353        link = hash_table_find(&port_hash_table, &port_id);
     354        assert(link != NULL);
     355        port = hash_table_get_inst(link, port_t, link);
     356        async_delete_port(port);
     357        fibril_rmutex_unlock(&port_mutex);
     358}
     359
    308360/** Initialize the async framework ports.
    309361 *

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

    r3951046 rca48672  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * Copyright (c) 2007 Josef Cejka
    44 * All rights reserved.
    … …  
    258258 * @param srv Server object
    259259 * @param fqsn Fully qualified service name
     260 * @param portid ID of port providing the service
    260261 * @param sid  Service ID of new service
    261262 *
    262263 */
    263264errno_t loc_service_register(loc_srv_t *srv, const char *fqsn,
    264     service_id_t *sid)
     265    port_id_t portid, service_id_t *sid)
    265266{
    266267        async_exch_t *exch = async_exchange_begin(srv->sess);
    267268        ipc_call_t answer;
    268         aid_t req = async_send_0(exch, LOC_SERVICE_REGISTER, &answer);
     269        aid_t req = async_send_1(exch, LOC_SERVICE_REGISTER, portid, &answer);
    269270        errno_t retval = async_data_write_start(exch, fqsn, str_size(fqsn));
    270271

  • uspace/lib/c/generic/ns.c

    r3951046 rca48672  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2011 Martin Decky
    34 * All rights reserved.
    … …  
    6869
    6970        if (rc != EOK) {
     71                async_port_destroy(port);
    7072                async_forget(req);
    7173                return rc;
    … …  
    7476        errno_t retval;
    7577        async_wait_for(req, &retval);
     78
     79        if (rc != EOK)
     80                async_port_destroy(port);
    7681        return rc;
    7782}

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

    r3951046 rca48672  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2006 Ondrej Palkovsky
    34 * All rights reserved.
    … …  
    99100} exch_mgmt_t;
    100101
     102enum {
     103        fallback_port_id = 0
     104};
     105
    101106/** Forward declarations */
    102107struct async_exch;
    … …  
    134139extern errno_t async_create_port(iface_t, async_port_handler_t, void *,
    135140    port_id_t *);
     141extern void async_port_destroy(port_id_t);
     142extern errno_t async_port_create_interface(port_id_t, iface_t,
     143    async_port_handler_t, void *);
    136144extern void async_set_fallback_port_handler(async_port_handler_t, void *);
    137145extern errno_t async_create_callback_port(async_exch_t *, iface_t, sysarg_t,

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

    r3951046 rca48672  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4949extern errno_t loc_server_register(const char *, loc_srv_t **);
    5050extern void loc_server_unregister(loc_srv_t *);
    51 extern errno_t loc_service_register(loc_srv_t *, const char *, service_id_t *);
     51extern errno_t loc_service_register(loc_srv_t *, const char *, port_id_t,
     52    service_id_t *);
    5253extern errno_t loc_service_unregister(loc_srv_t *, service_id_t);
    5354extern errno_t loc_service_add_to_cat(loc_srv_t *, service_id_t, category_id_t);

  • uspace/lib/c/test/loc.c

    r3951046 rca48672  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    5151
    5252        // XXX Without a unique name this is not reentrant
    53         rc = loc_service_register(sa, "test/libc-service-a", &svca);
     53        rc = loc_service_register(sa, "test/libc-service-a",
     54            fallback_port_id, &svca);
    5455        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    5556
    5657        // XXX Without a unique name this is not reentrant
    57         rc = loc_service_register(sb, "test/libc-service-b", &svcb);
     58        rc = loc_service_register(sb, "test/libc-service-b",
     59            fallback_port_id, &svcb);
    5860        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    5961

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

    r3951046 rca48672  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    8686        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    8787
    88         rc = loc_service_register(srv, test_ddev_svc, &sid);
     88        rc = loc_service_register(srv, test_ddev_svc, fallback_port_id, &sid);
    8989        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9090
    … …  
    115115        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    116116
    117         rc = loc_service_register(srv, test_ddev_svc, &sid);
     117        rc = loc_service_register(srv, test_ddev_svc, fallback_port_id, &sid);
    118118        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    119119
    … …  
    151151        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    152152
    153         rc = loc_service_register(srv, test_ddev_svc, &sid);
     153        rc = loc_service_register(srv, test_ddev_svc, fallback_port_id, &sid);
    154154        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    155155
    … …  
    196196        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    197197
    198         rc = loc_service_register(srv, test_ddev_svc, &sid);
     198        rc = loc_service_register(srv, test_ddev_svc, fallback_port_id, &sid);
    199199        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    200200
    … …  
    229229        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    230230
    231         rc = loc_service_register(srv, test_ddev_svc, &sid);
     231        rc = loc_service_register(srv, test_ddev_svc, fallback_port_id, &sid);
    232232        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    233233

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

    r3951046 rca48672  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    6060        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    6161
    62         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     62        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     63            &sid);
    6364        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    6465
    … …  
    8990        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9091
    91         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     92        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     93            &sid);
    9294        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9395
    … …  
    125127        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    126128
    127         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     129        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     130            &sid);
    128131        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    129132
    … …  
    174177        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    175178
    176         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     179        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     180            &sid);
    177181        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    178182
    … …  
    213217        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    214218
    215         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     219        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     220            &sid);
    216221        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    217222
    … …  
    258263        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    259264
    260         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     265        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     266            &sid);
    261267        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    262268
    … …  
    298304        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    299305
    300         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     306        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     307            &sid);
    301308        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    302309
    … …  
    338345        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    339346
    340         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     347        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     348            &sid);
    341349        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    342350
    … …  
    376384        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    377385
    378         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     386        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     387            &sid);
    379388        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    380389
    … …  
    415424        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    416425
    417         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     426        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     427            &sid);
    418428        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    419429
    … …  
    456466        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    457467
    458         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     468        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     469            &sid);
    459470        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    460471
    … …  
    496507        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    497508
    498         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     509        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     510            &sid);
    499511        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    500512
    … …  
    534546        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    535547
    536         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     548        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     549            &sid);
    537550        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    538551
    … …  
    573586        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    574587
    575         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     588        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     589            &sid);
    576590        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    577591
    … …  
    612626        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    613627
    614         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     628        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     629            &sid);
    615630        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    616631
    … …  
    661676        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    662677
    663         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     678        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     679            &sid);
    664680        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    665681
    … …  
    710726        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    711727
    712         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     728        rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
     729            &sid);
    713730        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    714731

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

    r3951046 rca48672  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    194194        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    195195
    196         rc = loc_service_register(srv, test_display_svc, &sid);
     196        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     197            &sid);
    197198        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    198199
    … …  
    224225        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    225226
    226         rc = loc_service_register(srv, test_display_svc, &sid);
     227        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     228            &sid);
    227229        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    228230
    … …  
    282284        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    283285
    284         rc = loc_service_register(srv, test_display_svc, &sid);
     286        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     287            &sid);
    285288        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    286289
    … …  
    339342        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    340343
    341         rc = loc_service_register(srv, test_display_svc, &sid);
     344        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     345            &sid);
    342346        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    343347
    … …  
    402406        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    403407
    404         rc = loc_service_register(srv, test_display_svc, &sid);
     408        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     409            &sid);
    405410        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    406411
    … …  
    462467        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    463468
    464         rc = loc_service_register(srv, test_display_svc, &sid);
     469        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     470            &sid);
    465471        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    466472
    … …  
    521527        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    522528
    523         rc = loc_service_register(srv, test_display_svc, &sid);
     529        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     530            &sid);
    524531        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    525532
    … …  
    577584        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    578585
    579         rc = loc_service_register(srv, test_display_svc, &sid);
     586        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     587            &sid);
    580588        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    581589
    … …  
    633641        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    634642
    635         rc = loc_service_register(srv, test_display_svc, &sid);
     643        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     644            &sid);
    636645        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    637646
    … …  
    690699        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    691700
    692         rc = loc_service_register(srv, test_display_svc, &sid);
     701        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     702            &sid);
    693703        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    694704
    … …  
    749759        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    750760
    751         rc = loc_service_register(srv, test_display_svc, &sid);
     761        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     762            &sid);
    752763        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    753764
    … …  
    810821        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    811822
    812         rc = loc_service_register(srv, test_display_svc, &sid);
     823        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     824            &sid);
    813825        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    814826
    … …  
    877889        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    878890
    879         rc = loc_service_register(srv, test_display_svc, &sid);
     891        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     892            &sid);
    880893        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    881894
    … …  
    940953        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    941954
    942         rc = loc_service_register(srv, test_display_svc, &sid);
     955        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     956            &sid);
    943957        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    944958
    … …  
    10021016        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10031017
    1004         rc = loc_service_register(srv, test_display_svc, &sid);
     1018        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1019            &sid);
    10051020        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10061021
    … …  
    10671082        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10681083
    1069         rc = loc_service_register(srv, test_display_svc, &sid);
     1084        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1085            &sid);
    10701086        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10711087
    … …  
    11291145        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    11301146
    1131         rc = loc_service_register(srv, test_display_svc, &sid);
     1147        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1148            &sid);
    11321149        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    11331150
    … …  
    11791196        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    11801197
    1181         rc = loc_service_register(srv, test_display_svc, &sid);
     1198        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1199            &sid);
    11821200        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    11831201
    … …  
    12291247        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    12301248
    1231         rc = loc_service_register(srv, test_display_svc, &sid);
     1249        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1250            &sid);
    12321251        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    12331252
    … …  
    12791298        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    12801299
    1281         rc = loc_service_register(srv, test_display_svc, &sid);
     1300        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1301            &sid);
    12821302        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    12831303
    … …  
    13291349        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    13301350
    1331         rc = loc_service_register(srv, test_display_svc, &sid);
     1351        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1352            &sid);
    13321353        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    13331354
    … …  
    13811402        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    13821403
    1383         rc = loc_service_register(srv, test_display_svc, &sid);
     1404        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1405            &sid);
    13841406        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    13851407
    … …  
    14341456        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    14351457
    1436         rc = loc_service_register(srv, test_display_svc, &sid);
     1458        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1459            &sid);
    14371460        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    14381461
    … …  
    14901513        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    14911514
    1492         rc = loc_service_register(srv, test_display_svc, &sid);
     1515        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1516            &sid);
    14931517        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    14941518
    … …  
    15461570        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    15471571
    1548         rc = loc_service_register(srv, test_display_svc, &sid);
     1572        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1573            &sid);
    15491574        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    15501575
    … …  
    16011626        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16021627
    1603         rc = loc_service_register(srv, test_display_svc, &sid);
     1628        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1629            &sid);
    16041630        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16051631
    … …  
    16621688        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16631689
    1664         rc = loc_service_register(srv, test_display_svc, &sid);
     1690        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1691            &sid);
    16651692        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16661693
    … …  
    17291756        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    17301757
    1731         rc = loc_service_register(srv, test_display_svc, &sid);
     1758        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1759            &sid);
    17321760        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    17331761
    … …  
    17991827        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18001828
    1801         rc = loc_service_register(srv, test_display_svc, &sid);
     1829        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1830            &sid);
    18021831        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18031832
    … …  
    18781907        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18791908
    1880         rc = loc_service_register(srv, test_display_svc, &sid);
     1909        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1910            &sid);
    18811911        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18821912
    … …  
    19571987        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19581988
    1959         rc = loc_service_register(srv, test_display_svc, &sid);
     1989        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1990            &sid);
    19601991        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19611992
    … …  
    20262057        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20272058
    2028         rc = loc_service_register(srv, test_display_svc, &sid);
     2059        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     2060            &sid);
    20292061        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20302062
    … …  
    20622094        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20632095
    2064         rc = loc_service_register(srv, test_display_svc, &sid);
     2096        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     2097            &sid);
    20652098        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20662099

  • uspace/lib/drv/generic/driver.c

    r3951046 rca48672  
    10461046errno_t ddf_driver_main(const driver_t *drv)
    10471047{
     1048        port_id_t drv_port;
     1049        port_id_t devman_port;
     1050
    10481051        /*
    10491052         * Remember the driver structure - driver_ops will be called by generic
    … …  
    10561059         * incoming connections.
    10571060         */
    1058         port_id_t port;
    1059         errno_t rc = async_create_port(INTERFACE_DDF_DRIVER, driver_connection_driver,
    1060             NULL, &port);
     1061        errno_t rc = async_create_port(INTERFACE_DDF_DRIVER,
     1062            driver_connection_driver, NULL, &drv_port);
    10611063        if (rc != EOK) {
    10621064                printf("Error: Failed to create driver port.\n");
    … …  
    10651067
    10661068        rc = async_create_port(INTERFACE_DDF_DEVMAN, driver_connection_devman,
    1067             NULL, &port);
     1069            NULL, &devman_port);
    10681070        if (rc != EOK) {
    10691071                printf("Error: Failed to create devman port.\n");
     1072                async_port_destroy(drv_port);
    10701073                return rc;
    10711074        }
    … …  
    10781081                    "(%s).\n", (rc == EEXIST) ? "driver already started" :
    10791082                    str_error(rc));
    1080 
     1083                async_port_destroy(devman_port);
     1084                async_port_destroy(drv_port);
    10811085                return rc;
    10821086        }
    … …  
    10861090        if (rc != EOK) {
    10871091                printf("Error: Failed returning task value.\n");
     1092                // XXX devman_driver_unregister
     1093                async_port_destroy(devman_port);
     1094                async_port_destroy(drv_port);
    10881095                return rc;
    10891096        }

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

    r3951046 rca48672  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * Copyright (c) 2012 Jan Vesely
    44 * All rights reserved.
    … …  
    746746                return rc;
    747747
    748         rc = loc_service_register(hound_srv, HOUND_SERVICE, id);
     748        rc = loc_service_register(hound_srv, HOUND_SERVICE,
     749            fallback_port_id, id);
    749750        if (rc != EOK) {
    750751                loc_server_unregister(hound_srv);

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

    r3951046 rca48672  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    128128        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    129129
    130         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     130        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    131131        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    132132
    … …  
    180180        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    181181
    182         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     182        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    183183        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    184184
    … …  
    232232        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    233233
    234         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     234        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    235235        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    236236
    … …  
    278278        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    279279
    280         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     280        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    281281        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    282282
    … …  
    330330        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    331331
    332         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     332        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    333333        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    334334
    … …  
    382382        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    383383
    384         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     384        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    385385        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    386386
    … …  
    434434        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    435435
    436         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     436        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    437437        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    438438
    … …  
    485485        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    486486
    487         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     487        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    488488        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    489489
    … …  
    528528        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    529529
    530         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     530        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    531531        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    532532
    … …  
    573573        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    574574
    575         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     575        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    576576        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    577577
    … …  
    634634        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    635635
    636         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     636        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    637637        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    638638
    … …  
    700700        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    701701
    702         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     702        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    703703        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    704704
    … …  
    755755        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    756756
    757         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     757        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    758758        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    759759
    … …  
    817817        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    818818
    819         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     819        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    820820        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    821821
    … …  
    886886        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    887887
    888         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     888        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    889889        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    890890
    … …  
    956956        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    957957
    958         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     958        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    959959        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    960960
    … …  
    10251025        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10261026
    1027         rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
     1027        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    10281028        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10291029

  • uspace/lib/system/test/system.c

    r3951046 rca48672  
    9393        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9494
    95         rc = loc_service_register(srv, test_system_svc, &sid);
     95        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
    9696        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9797
    … …  
    121121        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    122122
    123         rc = loc_service_register(srv, test_system_svc, &sid);
     123        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
    124124        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    125125
    … …  
    156156        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    157157
    158         rc = loc_service_register(srv, test_system_svc, &sid);
     158        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
    159159        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    160160
    … …  
    191191        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    192192
    193         rc = loc_service_register(srv, test_system_svc, &sid);
     193        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
    194194        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    195195
    … …  
    226226        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    227227
    228         rc = loc_service_register(srv, test_system_svc, &sid);
     228        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
    229229        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    230230
    … …  
    263263        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    264264
    265         rc = loc_service_register(srv, test_system_svc, &sid);
     265        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
    266266        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    267267
    … …  
    307307        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    308308
    309         rc = loc_service_register(srv, test_system_svc, &sid);
     309        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
    310310        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    311311

  • uspace/lib/tbarcfg/src/tbarcfg.c

    r3951046 rca48672  
    11/*
    2  * Copyright (c) 2024 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    639639        char *svcname = NULL;
    640640        category_id_t catid;
    641         port_id_t port;
     641        port_id_t port = 0;
    642642        int rv;
    643643        errno_t rc;
    … …  
    667667        }
    668668
    669         rc = loc_service_register(srv, svcname, &svcid);
     669        rc = loc_service_register(srv, svcname, port, &svcid);
    670670        if (rc != EOK)
    671671                goto error;
    … …  
    688688        if (svcname != NULL)
    689689                free(svcname);
     690        if (port != 0)
     691                async_port_destroy(port);
    690692        return rc;
    691693}

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

    r3951046 rca48672  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    125125        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    126126
    127         rc = loc_service_register(srv, test_wndmgt_svc, &sid);
     127        rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
    128128        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    129129
    … …  
    154154        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    155155
    156         rc = loc_service_register(srv, test_wndmgt_svc, &sid);
     156        rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
    157157        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    158158
    … …  
    190190        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    191191
    192         rc = loc_service_register(srv, test_wndmgt_svc, &sid);
     192        rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
    193193        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    194194
    … …  
    239239        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    240240
    241         rc = loc_service_register(srv, test_wndmgt_svc, &sid);
     241        rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
    242242        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    243243
    … …  
    278278        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    279279
    280         rc = loc_service_register(srv, test_wndmgt_svc, &sid);
     280        rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
    281281        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    282282
    … …  
    328328        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    329329
    330         rc = loc_service_register(srv, test_wndmgt_svc, &sid);
     330        rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
    331331        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    332332
    … …  
    369369        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    370370
    371         rc = loc_service_register(srv, test_wndmgt_svc, &sid);
     371        rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
    372372        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    373373
    … …  
    409409        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    410410
    411         rc = loc_service_register(srv, test_wndmgt_svc, &sid);
     411        rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
    412412        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    413413
    … …  
    447447        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    448448
    449         rc = loc_service_register(srv, test_wndmgt_svc, &sid);
     449        rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
    450450        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    451451
    … …  
    484484        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    485485
    486         rc = loc_service_register(srv, test_wndmgt_svc, &sid);
     486        rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
    487487        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    488488
    … …  
    533533        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    534534
    535         rc = loc_service_register(srv, test_wndmgt_svc, &sid);
     535        rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
    536536        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    537537
    … …  
    582582        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    583583
    584         rc = loc_service_register(srv, test_wndmgt_svc, &sid);
     584        rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
    585585        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    586586
Note: See TracChangeset for help on using the changeset viewer.