Changeset f0cc1c64 in mainline for uspace/lib


Ignore:
Timestamp:
2025-06-20T19:26:13Z (8 months ago)
Author:
Miroslav Cimerman <mc@…>
Children:
817cb83
Parents:
f0360ec (diff), 5caad1d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge upstream into helenraid

Location:
uspace/lib
Files:
2 deleted
20 edited

Legend:

Unmodified
Added
Removed

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

    rf0360ec rf0cc1c64  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2006 Ondrej Palkovsky
    34 * All rights reserved.
    … …  
    5960        iface_t iface;
    6061
    61         /** Interface ports */
    62         hash_table_t port_hash_table;
    63 
    64         /** Next available port ID */
    65         port_id_t port_id_avail;
     62        /** Interface connection handler */
     63        async_port_handler_t handler;
     64
     65        /** Client data */
     66        void *data;
    6667} interface_t;
    6768
    … …  
    7374        port_id_t id;
    7475
    75         /** Port connection handler */
    76         async_port_handler_t handler;
    77 
    78         /** Client data */
    79         void *data;
     76        /** Port interfaces */
     77        hash_table_t interface_hash_table;
    8078} port_t;
    8179
    … …  
    9896static void *fallback_port_data = NULL;
    9997
    100 /** Futex guarding the interface hash table. */
    101 static fibril_rmutex_t interface_mutex;
    102 static hash_table_t interface_hash_table;
     98/** Futex guarding the port hash table. */
     99static fibril_rmutex_t port_mutex;
     100static hash_table_t port_hash_table;
     101/** Next available port ID */
     102static port_id_t port_id_avail = 0;
    103103
    104104static size_t interface_key_hash(const void *key)
    … …  
    158158};
    159159
    160 static interface_t *async_new_interface(iface_t iface)
     160static interface_t *async_new_interface(port_t *port, iface_t iface,
     161    async_port_handler_t handler, void *data)
    161162{
    162163        interface_t *interface =
    … …  
    164165        if (!interface)
    165166                return NULL;
    166 
    167         bool ret = hash_table_create(&interface->port_hash_table, 0, 0,
    168             &port_hash_table_ops);
    169         if (!ret) {
    170                 free(interface);
    171                 return NULL;
    172         }
    173 
    174167        interface->iface = iface;
    175         interface->port_id_avail = 0;
    176 
    177         hash_table_insert(&interface_hash_table, &interface->link);
     168        interface->handler = handler;
     169        interface->data = data;
     170
     171        hash_table_insert(&port->interface_hash_table, &interface->link);
    178172
    179173        return interface;
    180174}
    181175
    182 static port_t *async_new_port(interface_t *interface,
    183     async_port_handler_t handler, void *data)
     176static port_t *async_new_port(void)
    184177{
    185178        // TODO: Move the malloc out of critical section.
    … …  
    188181                return NULL;
    189182
    190         port_id_t id = interface->port_id_avail;
    191         interface->port_id_avail++;
     183        bool ret = hash_table_create(&port->interface_hash_table, 0, 0,
     184            &interface_hash_table_ops);
     185        if (!ret) {
     186                free(port);
     187                return NULL;
     188        }
     189
     190        port_id_t id = port_id_avail;
     191        port_id_avail++;
    192192
    193193        port->id = id;
    194         port->handler = handler;
    195         port->data = data;
    196 
    197         hash_table_insert(&interface->port_hash_table, &port->link);
     194        hash_table_insert(&port_hash_table, &port->link);
    198195
    199196        return port;
     197}
     198
     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, port);
     211
     212        hash_table_destroy(&port->interface_hash_table);
     213        free(port);
    200214}
    201215
    … …  
    205219        interface_t *interface;
    206220
    207         fibril_rmutex_lock(&interface_mutex);
    208 
    209         ht_link_t *link = hash_table_find(&interface_hash_table, &iface);
    210         if (link)
    211                 interface = hash_table_get_inst(link, interface_t, link);
    212         else
    213                 interface = async_new_interface(iface);
    214 
    215         if (!interface) {
    216                 fibril_rmutex_unlock(&interface_mutex);
     221        fibril_rmutex_lock(&port_mutex);
     222
     223        port_t *port = async_new_port();
     224        if (port == NULL) {
     225                fibril_rmutex_unlock(&port_mutex);
    217226                return ENOMEM;
    218227        }
    219228
    220         port_t *port = async_new_port(interface, handler, data);
    221         if (!port) {
    222                 fibril_rmutex_unlock(&interface_mutex);
     229        interface = async_new_interface(port, iface, handler, data);
     230        if (interface == NULL) {
     231                async_delete_port(port);
     232                fibril_rmutex_unlock(&port_mutex);
    223233                return ENOMEM;
    224234        }
    225235
    226236        *port_id = port->id;
    227 
    228         fibril_rmutex_unlock(&interface_mutex);
    229 
     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
     259        fibril_rmutex_unlock(&port_mutex);
    230260        return EOK;
    231261}
    … …  
    248278}
    249279
    250 static port_t *async_find_port(iface_t iface, port_id_t port_id)
    251 {
    252         port_t *port = NULL;
    253 
    254         fibril_rmutex_lock(&interface_mutex);
    255 
    256         ht_link_t *link = hash_table_find(&interface_hash_table, &iface);
    257         if (link) {
    258                 interface_t *interface =
    259                     hash_table_get_inst(link, interface_t, link);
    260 
    261                 link = hash_table_find(&interface->port_hash_table, &port_id);
    262                 if (link)
    263                         port = hash_table_get_inst(link, port_t, link);
    264         }
    265 
    266         fibril_rmutex_unlock(&interface_mutex);
    267 
    268         return port;
    269 }
    270 
    271 async_port_handler_t async_get_port_handler(iface_t iface, port_id_t port_id,
    272     void **data)
     280typedef struct {
     281        iface_t iface;
     282        interface_t *interface;
     283} find_if_port_t;
     284
     285static bool find_if_port(ht_link_t *link, void *arg)
     286{
     287        find_if_port_t *fip = (find_if_port_t *)arg;
     288        port_t *port;
     289        interface_t *interface;
     290
     291        (void)arg;
     292        port = hash_table_get_inst(link, port_t, link);
     293
     294        ht_link_t *ilink = hash_table_find(&port->interface_hash_table,
     295            &fip->iface);
     296        if (ilink) {
     297                interface = hash_table_get_inst(ilink, interface_t,
     298                    link);
     299                fip->interface = interface;
     300                return false;
     301        }
     302
     303        return true;
     304}
     305
     306static interface_t *async_find_interface(iface_t iface, port_id_t port_id)
     307{
     308        interface_t *interface = NULL;
     309        find_if_port_t fip;
     310
     311        (void)port_id; // XXX !!!
     312
     313        fibril_rmutex_lock(&port_mutex);
     314
     315        /*
     316         * XXX Find any port implementing that interface. In reality we should
     317         * only look at port with ID port_id - but server.c does not
     318         * provide us with a correct port ID
     319         */
     320
     321        fip.iface = iface;
     322        fip.interface = NULL;
     323        hash_table_apply(&port_hash_table, find_if_port, (void *)&fip);
     324        interface = fip.interface;
     325
     326        fibril_rmutex_unlock(&port_mutex);
     327        return interface;
     328}
     329
     330async_port_handler_t async_get_interface_handler(iface_t iface,
     331    port_id_t port_id, void **data)
    273332{
    274333        assert(data);
    … …  
    277336        *data = fallback_port_data;
    278337
    279         port_t *port = async_find_port(iface, port_id);
    280         if (port) {
    281                 handler = port->handler;
    282                 *data = port->data;
     338        interface_t *interface = async_find_interface(iface, port_id);
     339        if (interface != NULL) {
     340                handler = interface->handler;
     341                *data = interface->data;
    283342        }
    284343
    … …  
    286345}
    287346
    288 /** Initialize the async framework.
     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
     360/** Initialize the async framework ports.
    289361 *
    290362 */
    291363void __async_ports_init(void)
    292364{
    293         if (fibril_rmutex_initialize(&interface_mutex) != EOK)
     365        if (fibril_rmutex_initialize(&port_mutex) != EOK)
    294366                abort();
    295367
    296         if (!hash_table_create(&interface_hash_table, 0, 0,
    297             &interface_hash_table_ops))
     368        if (!hash_table_create(&port_hash_table, 0, 0, &port_hash_table_ops))
    298369                abort();
    299370}
    … …  
    301372void __async_ports_fini(void)
    302373{
    303         fibril_rmutex_destroy(&interface_mutex);
    304 }
     374        fibril_rmutex_destroy(&port_mutex);
     375}

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

    rf0360ec rf0cc1c64  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2006 Ondrej Palkovsky
    34 * All rights reserved.
    … …  
    955956                void *data;
    956957                async_port_handler_t handler =
    957                     async_get_port_handler(iface, 0, &data);
     958                    async_get_interface_handler(iface, 0, &data);
    958959
    959960                async_new_connection(conn, call->task_id, call, handler, data);

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

    rf0360ec rf0cc1c64  
    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

    rf0360ec rf0cc1c64  
    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/generic/private/async.h

    rf0360ec rf0cc1c64  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2006 Ondrej Palkovsky
    34 * All rights reserved.
    … …  
    103104extern errno_t async_create_port_internal(iface_t, async_port_handler_t,
    104105    void *, port_id_t *);
    105 extern async_port_handler_t async_get_port_handler(iface_t, port_id_t, void **);
     106extern async_port_handler_t async_get_interface_handler(iface_t, port_id_t,
     107    void **);
    106108
    107109extern void async_reply_received(ipc_call_t *);

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

    rf0360ec rf0cc1c64  
    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

    rf0360ec rf0cc1c64  
    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

    rf0360ec rf0cc1c64  
    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

    rf0360ec rf0cc1c64  
    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

    rf0360ec rf0cc1c64  
    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

    rf0360ec rf0cc1c64  
    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/dev_iface.c

    rf0360ec rf0cc1c64  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2010 Lenka Trochtova
    34 * All rights reserved.
    … …  
    5354#include "remote_audio_mixer.h"
    5455#include "remote_audio_pcm.h"
    55 #include "remote_ahci.h"
    5656
    5757static const iface_dipatch_table_t remote_ifaces = {
    … …  
    7171                [LED_DEV_IFACE] = &remote_led_dev_iface,
    7272                [BATTERY_DEV_IFACE] = &remote_battery_dev_iface,
    73                 [AHCI_DEV_IFACE] = &remote_ahci_iface,
    7473        }
    7574};

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

    rf0360ec rf0cc1c64  
    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/drv/meson.build

    rf0360ec rf0cc1c64  
    11#
     2# Copyright (c) 2025 Jiri Svoboda
    23# Copyright (c) 2005 Martin Decky
    34# Copyright (c) 2007 Jakub Jermar
    … …  
    5051        'generic/remote_led_dev.c',
    5152        'generic/remote_battery_dev.c',
    52         'generic/remote_ahci.c',
    5353)

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

    rf0360ec rf0cc1c64  
    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

    rf0360ec rf0cc1c64  
    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

    rf0360ec rf0cc1c64  
    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/private/tbarcfg.h

    rf0360ec rf0cc1c64  
    11/*
    2  * Copyright (c) 2024 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3939
    4040#include <adt/list.h>
     41#include <loc.h>
    4142#include <stdbool.h>
    4243#include <types/tbarcfg/tbarcfg.h>
    … …  
    6869/** Taskbar configuration listener */
    6970typedef struct tbarcfg_listener {
     71        /** Async port */
     72        port_id_t portid;
     73        /** Registered server */
     74        loc_srv_t *srv;
     75        /** Registered service */
     76        service_id_t svcid;
    7077        /** Notification callback */
    7178        void (*cb)(void *);

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

    rf0360ec rf0cc1c64  
    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);
    670         if (rc != EOK)
    671                 goto error;
     669        rc = loc_service_register(srv, svcname, port, &svcid);
     670        if (rc != EOK)
     671                goto error;
     672
     673        free(svcname);
     674        svcname = NULL;
    672675
    673676        rc = loc_category_get_id(nchan, &catid, 0);
    … …  
    679682                goto error;
    680683
     684        lst->portid = port;
     685        lst->srv = srv;
     686        lst->svcid = svcid;
    681687        *rlst = lst;
    682688        return EOK;
    … …  
    688694        if (svcname != NULL)
    689695                free(svcname);
     696        if (port != 0)
     697                async_port_destroy(port);
    690698        return rc;
    691699}
    … …  
    697705void tbarcfg_listener_destroy(tbarcfg_listener_t *lst)
    698706{
     707        loc_service_unregister(lst->srv, lst->svcid);
     708        loc_server_unregister(lst->srv);
     709        async_port_destroy(lst->portid);
    699710        free(lst);
    700711}

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

    rf0360ec rf0cc1c64  
    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.