Changeset 4c6fd56 in mainline for uspace/srv


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/srv
Files:
33 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/bd/file_bd/file_bd.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    6161static aoff64_t num_blocks;
    6262static FILE *img;
     63static loc_srv_t *srv;
    6364
    6465static service_id_t service_id;
    … …  
    137138                return -1;
    138139
    139         rc = loc_service_register(device_name, &service_id);
     140        rc = loc_service_register(srv, device_name, &service_id);
    140141        if (rc != EOK) {
    141142                printf("%s: Unable to register device '%s': %s.\n",
    … …  
    150151        }
    151152
    152         rc = loc_service_add_to_cat(service_id, disk_cat);
     153        rc = loc_service_add_to_cat(srv, service_id, disk_cat);
    153154        if (rc != EOK) {
    154155                printf("%s: Failed adding %s to category: %s",
    … …  
    176177
    177178        async_set_fallback_port_handler(file_bd_connection, NULL);
    178         errno_t rc = loc_server_register(NAME);
     179        errno_t rc = loc_server_register(NAME, &srv);
    179180        if (rc != EOK) {
    180181                printf("%s: Unable to register driver.\n", NAME);
    … …  
    183184
    184185        img = fopen(fname, "rb+");
    185         if (img == NULL)
    186                 return EINVAL;
     186        if (img == NULL) {
     187                rc = EINVAL;
     188                goto error;
     189        }
    187190
    188191        if (fseek(img, 0, SEEK_END) != 0) {
    189                 fclose(img);
    190                 return EIO;
     192                rc = EIO;
     193                goto error;
    191194        }
    192195
    193196        off64_t img_size = ftell(img);
    194197        if (img_size < 0) {
     198                rc = EIO;
     199                goto error;
     200        }
     201
     202        num_blocks = img_size / block_size;
     203
     204        fibril_mutex_initialize(&dev_lock);
     205
     206        return EOK;
     207error:
     208        if (img != NULL) {
    195209                fclose(img);
    196                 return EIO;
    197         }
    198 
    199         num_blocks = img_size / block_size;
    200 
    201         fibril_mutex_initialize(&dev_lock);
    202 
    203         return EOK;
     210                img = NULL;
     211        }
     212
     213        if (srv != NULL) {
     214                loc_server_unregister(srv);
     215                srv = NULL;
     216        }
     217
     218        return rc;
    204219}
    205220

  • uspace/srv/bd/rd/rd.c

    r6a0b2cc r4c6fd56  
    11/*
     2 * Copyright (c) 2023 Jiri Svoboda
    23 * Copyright (c) 2007 Michal Konopa
    34 * Copyright (c) 2007 Martin Jelen
    … …  
    9394
    9495static bd_srvs_t bd_srvs;
     96static loc_srv_t *srv;
    9597
    9698static void rd_client_conn(ipc_call_t *icall, void *arg)
    … …  
    178180
    179181        async_set_fallback_port_handler(rd_client_conn, NULL);
    180         ret = loc_server_register(NAME);
     182        ret = loc_server_register(NAME, &srv);
    181183        if (ret != EOK) {
    182184                printf("%s: Unable to register driver: %s\n", NAME, str_error(ret));
    … …  
    185187
    186188        service_id_t service_id;
    187         ret = loc_service_register("bd/initrd", &service_id);
     189        ret = loc_service_register(srv, "bd/initrd", &service_id);
    188190        if (ret != EOK) {
    189191                printf("%s: Unable to register device service\n", NAME);

  • uspace/srv/bd/sata_bd/sata_bd.c

    r6a0b2cc r4c6fd56  
    11/*
     2 * Copyright (c) 2023 Jiri Svoboda
    23 * Copyright (c) 2012 Petr Jerman
    34 * All rights reserved.
    … …  
    5758#define MAXDISKS  256
    5859
     60static loc_srv_t *srv;
    5961static sata_bd_dev_t disk[MAXDISKS];
    6062static int disk_count;
    … …  
    249251
    250252        async_set_fallback_port_handler(sata_bd_connection, NULL);
    251         rc = loc_server_register(NAME);
     253        rc = loc_server_register(NAME, &srv);
    252254        if (rc != EOK) {
    253255                printf(NAME ": Unable to register driver: %s.\n", str_error(rc));
    … …  
    270272                char name[1024];
    271273                snprintf(name, 1024, "%s/%s", NAMESPACE, disk[i].dev_name);
    272                 rc = loc_service_register(name, &disk[i].service_id);
     274                rc = loc_service_register(srv, name, &disk[i].service_id);
    273275                if (rc != EOK) {
    274276                        printf(NAME ": Unable to register device %s: %s\n", name, str_error(rc));
    … …  
    276278                }
    277279
    278                 rc = loc_service_add_to_cat(disk[i].service_id, disk_cat);
     280                rc = loc_service_add_to_cat(srv, disk[i].service_id, disk_cat);
    279281                if (rc != EOK) {
    280282                        printf("%s: Failed adding %s to category: %s.",

  • uspace/srv/bd/vbd/disk.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2016 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    5151#include "types/vbd.h"
    5252
     53loc_srv_t *vbds_srv;
     54
    5355static fibril_mutex_t vbds_disks_lock;
    5456static list_t vbds_disks; /* of vbds_disk_t */
    … …  
    11221124        log_msg(LOG_DEFAULT, LVL_DEBUG, "loc_service_register('%s')",
    11231125            name);
    1124         rc = loc_service_register(name, &psid);
     1126        rc = loc_service_register(vbds_srv, name, &psid);
    11251127        if (rc != EOK) {
    11261128                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering "
    … …  
    11311133        }
    11321134
    1133         rc = loc_service_add_to_cat(psid, part_cid);
     1135        rc = loc_service_add_to_cat(vbds_srv, psid, part_cid);
    11341136        if (rc != EOK) {
    11351137                log_msg(LOG_DEFAULT, LVL_ERROR, "Failled adding partition "
    … …  
    11381140                free(part);
    11391141
    1140                 rc = loc_service_unregister(psid);
     1142                rc = loc_service_unregister(vbds_srv, psid);
    11411143                if (rc != EOK) {
    11421144                        log_msg(LOG_DEFAULT, LVL_ERROR, "Error unregistering "
    … …  
    11601162            "disk->svc_name='%s', id=%zu)", part->disk->svc_name, part->svc_id);
    11611163
    1162         rc = loc_service_unregister(part->svc_id);
     1164        rc = loc_service_unregister(vbds_srv, part->svc_id);
    11631165        if (rc != EOK)
    11641166                return EIO;

  • uspace/srv/bd/vbd/disk.h

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2015 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    5757extern void vbds_bd_conn(ipc_call_t *, void *);
    5858
     59extern loc_srv_t *vbds_srv;
     60
    5961#endif
    6062

  • uspace/srv/bd/vbd/vbd.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2015 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    6868        async_set_fallback_port_handler(vbds_client_conn, NULL);
    6969
    70         rc = loc_server_register(NAME);
     70        rc = loc_server_register(NAME, &vbds_srv);
    7171        if (rc != EOK) {
    7272                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server: %s.", str_error(rc));
    … …  
    7474        }
    7575
    76         rc = loc_service_register(SERVICE_NAME_VBD, &ctl_sid);
     76        rc = loc_service_register(vbds_srv, SERVICE_NAME_VBD, &ctl_sid);
    7777        if (rc != EOK) {
    7878                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service: %s.", str_error(rc));

  • uspace/srv/clipboard/clipboard.c

    r6a0b2cc r4c6fd56  
    11/*
     2 * Copyright (c) 2023 Jiri Svoboda
    23 * Copyright (c) 2009 Martin Decky
    34 * All rights reserved.
    … …  
    185186{
    186187        errno_t rc;
     188        loc_srv_t *srv;
    187189
    188190        printf("%s: HelenOS clipboard service\n", NAME);
    189191        async_set_fallback_port_handler(clip_connection, NULL);
    190192
    191         rc = loc_server_register(NAME);
     193        rc = loc_server_register(NAME, &srv);
    192194        if (rc != EOK) {
    193195                printf("%s: Failed registering server: %s\n", NAME, str_error(rc));
    … …  
    195197        }
    196198
    197         rc = loc_service_register(SERVICE_NAME_CLIPBOARD, &svc_id);
     199        rc = loc_service_register(srv, SERVICE_NAME_CLIPBOARD, &svc_id);
    198200        if (rc != EOK) {
     201                loc_server_unregister(srv);
     202
    199203                printf("%s: Failed registering service : %s\n", NAME, str_error(rc));
    200204                return rc;

  • uspace/srv/devman/drv_conn.c

    r6a0b2cc r4c6fd56  
    11/*
     2 * Copyright (c) 2023 Jiri Svoboda
    23 * Copyright (c) 2010 Lenka Trochtova
    34 * All rights reserved.
    … …  
    360361        rc = loc_category_get_id(cat_name, &cat_id, IPC_FLAG_BLOCKING);
    361362        if (rc == EOK)
    362                 rc = loc_service_add_to_cat(fun->service_id, cat_id);
     363                rc = loc_service_add_to_cat(devman_srv, fun->service_id, cat_id);
    363364        if (rc == EOK) {
    364365                log_msg(LOG_DEFAULT, LVL_NOTE, "Function `%s' added to category `%s'.",

  • uspace/srv/devman/loc.c

    r6a0b2cc r4c6fd56  
    11/*
     2 * Copyright (c) 2023 Jiri Svoboda
    23 * Copyright (c) 2010 Lenka Trochtova
    34 * All rights reserved.
    … …  
    3738#include "fun.h"
    3839#include "loc.h"
     40#include "main.h"
    3941
    4042/** Create loc path and name for the function. */
    … …  
    5961        }
    6062
    61         loc_service_register(loc_pathname, &fun->service_id);
     63        loc_service_register(devman_srv, loc_pathname, &fun->service_id);
    6264
    6365        tree_add_loc_function(tree, fun);
    … …  
    6971errno_t loc_unregister_tree_function(fun_node_t *fun, dev_tree_t *tree)
    7072{
    71         errno_t rc = loc_service_unregister(fun->service_id);
     73        errno_t rc = loc_service_unregister(devman_srv, fun->service_id);
    7274        tree_rem_loc_function(tree, fun);
    7375        return rc;

  • uspace/srv/devman/main.c

    r6a0b2cc r4c6fd56  
    11/*
     2 * Copyright (c) 2023 Jiri Svoboda
    23 * Copyright (c) 2010 Lenka Trochtova
    34 * All rights reserved.
    … …  
    6465driver_list_t drivers_list;
    6566dev_tree_t device_tree;
     67loc_srv_t *devman_srv;
    6668
    6769static void devman_connection_device(ipc_call_t *icall, void *arg)
    … …  
    280282static bool devman_init(void)
    281283{
     284        errno_t rc;
     285
    282286        log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_init - looking for available drivers.");
    283287
    … …  
    305309         * not work.
    306310         */
    307         loc_server_register(NAME);
     311        rc = loc_server_register(NAME, &devman_srv);
     312        if (rc != EOK) {
     313                log_msg(LOG_DEFAULT, LVL_FATAL, "Error registering devman server.");
     314                return false;
     315        }
    308316
    309317        return true;

  • uspace/srv/devman/main.h

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2013 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3434#define MAIN_H_
    3535
     36#include <loc.h>
    3637#include "devman.h"
    3738
    3839extern driver_list_t drivers_list;
    3940extern dev_tree_t device_tree;
     41extern loc_srv_t *devman_srv;
    4042
    4143#endif

  • uspace/srv/hid/console/console.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2022 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * Copyright (c) 2011 Martin Decky
    44 * All rights reserved.
    … …  
    8989} console_t;
    9090
     91static loc_srv_t *console_srv;
     92
    9193/** Input server proxy */
    9294static input_t *input;
    … …  
    902904        /* Register server */
    903905        async_set_fallback_port_handler(client_connection, NULL);
    904         rc = loc_server_register(NAME);
     906        rc = loc_server_register(NAME, &console_srv);
    905907        if (rc != EOK) {
    906908                printf("%s: Unable to register server (%s)\n", NAME,
    … …  
    952954                        snprintf(vc, LOC_NAME_MAXLEN, "%s/vc%zu", NAMESPACE, i);
    953955
    954                         if (loc_service_register(vc, &consoles[i].dsid) != EOK) {
     956                        if (loc_service_register(console_srv, vc,
     957                            &consoles[i].dsid) != EOK) {
    955958                                printf("%s: Unable to register device %s\n", NAME, vc);
    956959                                return false;

  • uspace/srv/hid/display/main.c

    r6a0b2cc r4c6fd56  
    127127        port_id_t wm_port;
    128128        port_id_t dc_port;
     129        loc_srv_t *srv = NULL;
     130        service_id_t sid = 0;
    129131        errno_t rc;
    130132
    … …  
    171173                goto error;
    172174
    173         rc = loc_server_register(NAME);
     175        rc = loc_server_register(NAME, &srv);
    174176        if (rc != EOK) {
    175177                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server: %s.", str_error(rc));
    … …  
    178180        }
    179181
    180         service_id_t sid;
    181         rc = loc_service_register(SERVICE_NAME_DISPLAY, &sid);
     182        rc = loc_service_register(srv, SERVICE_NAME_DISPLAY, &sid);
    182183        if (rc != EOK) {
    183184                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service: %s.", str_error(rc));
    … …  
    189190        return EOK;
    190191error:
     192        if (sid != 0)
     193                loc_service_unregister(srv, sid);
     194        if (srv != NULL)
     195                loc_server_unregister(srv);
    191196        // XXX destroy disp_port
    192197        // XXX destroy gc_port

  • uspace/srv/hid/input/input.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2022 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * Copyright (c) 2006 Josef Cejka
    44 * All rights reserved.
    … …  
    878878{
    879879        errno_t rc;
     880        loc_srv_t *srv;
    880881
    881882        if (argc < 2) {
    … …  
    901902        async_set_fallback_port_handler(client_connection, NULL);
    902903
    903         rc = loc_server_register(NAME);
     904        rc = loc_server_register(NAME, &srv);
    904905        if (rc != EOK) {
    905906                printf("%s: Unable to register server\n", NAME);
    … …  
    908909
    909910        service_id_t service_id;
    910         rc = loc_service_register(argv[1], &service_id);
     911        rc = loc_service_register(srv, argv[1], &service_id);
    911912        if (rc != EOK) {
    912913                printf("%s: Unable to register service %s\n", NAME, argv[1]);

  • uspace/srv/hid/isdv4_tablet/main.c

    r6a0b2cc r4c6fd56  
    11/*
     2 * Copyright (c) 2023 Jiri Svoboda
    23 * Copyright (c) 2012 Martin Sucha
    34 * All rights reserved.
    … …  
    184185        serial_t *serial;
    185186        char *serial_port_name = NULL;
     187        loc_srv_t *srv;
    186188
    187189        int arg = 1;
    … …  
    315317
    316318        async_set_fallback_port_handler(mouse_connection, NULL);
    317         rc = loc_server_register(NAME);
     319        rc = loc_server_register(NAME, &srv);
    318320        if (rc != EOK) {
    319321                printf("%s: Unable to register driver.\n", NAME);
    … …  
    329331        }
    330332
    331         rc = loc_service_register(service_name, &service_id);
    332         if (rc != EOK) {
     333        rc = loc_service_register(srv, service_name, &service_id);
     334        if (rc != EOK) {
     335                loc_server_unregister(srv);
    333336                printf(NAME ": Unable to register service %s.\n", service_name);
    334337                return rc;
    … …  
    340343                printf(NAME ": Unable to get mouse category id.\n");
    341344        } else {
    342                 rc = loc_service_add_to_cat(service_id, mouse_category);
     345                rc = loc_service_add_to_cat(srv, service_id, mouse_category);
    343346                if (rc != EOK) {
    344347                        printf(NAME ": Unable to add device to mouse category.\n");

  • uspace/srv/hid/output/output.c

    r6a0b2cc r4c6fd56  
    11/*
     2 * Copyright (c) 2023 Jiri Svoboda
    23 * Copyright (c) 2011 Martin Decky
    34 * All rights reserved.
    … …  
    468469int main(int argc, char *argv[])
    469470{
     471        loc_srv_t *srv;
     472
    470473        if (argc < 2) {
    471474                usage(argv[0]);
    … …  
    477480        /* Register server */
    478481        async_set_fallback_port_handler(client_connection, NULL);
    479         errno_t rc = loc_server_register(NAME);
     482        errno_t rc = loc_server_register(NAME, &srv);
    480483        if (rc != EOK) {
    481484                printf("%s: Unable to register driver\n", NAME);
    … …  
    484487
    485488        service_id_t service_id;
    486         rc = loc_service_register(argv[1], &service_id);
     489        rc = loc_service_register(srv, argv[1], &service_id);
    487490        if (rc != EOK) {
     491                loc_server_unregister(srv);
     492
    488493                printf("%s: Unable to register service %s\n", NAME, argv[1]);
    489494                return rc;

  • uspace/srv/hid/remcons/remcons.c

    r6a0b2cc r4c6fd56  
    11/*
     2 * Copyright (c) 2023 Jiri Svoboda
    23 * Copyright (c) 2012 Vojtech Horky
    34 * All rights reserved.
    … …  
    110111};
    111112
     113static loc_srv_t *remcons_srv;
     114
    112115static telnet_user_t *srv_to_user(con_srv_t *srv)
    113116{
    … …  
    301304        telnet_user_add(user);
    302305
    303         errno_t rc = loc_service_register(user->service_name, &user->service_id);
     306        errno_t rc = loc_service_register(remcons_srv, user->service_name,
     307            &user->service_id);
    304308        if (rc != EOK) {
    305309                telnet_user_error(user, "Unable to register %s with loc: %s.",
    … …  
    332336        fibril_mutex_unlock(&user->guard);
    333337
    334         rc = loc_service_unregister(user->service_id);
     338        rc = loc_service_unregister(remcons_srv, user->service_id);
    335339        if (rc != EOK) {
    336340                telnet_user_error(user,
    … …  
    351355
    352356        async_set_fallback_port_handler(client_connection, NULL);
    353         rc = loc_server_register(NAME);
     357        rc = loc_server_register(NAME, &remcons_srv);
    354358        if (rc != EOK) {
    355359                fprintf(stderr, "%s: Unable to register server\n", NAME);

  • uspace/srv/hid/rfb/main.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2021 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * Copyright (c) 2013 Martin Sucha
    44 * All rights reserved.
    … …  
    443443{
    444444        rfb_t rfb;
     445        loc_srv_t *srv;
    445446
    446447        log_init(NAME);
    … …  
    482483        async_set_fallback_port_handler(client_connection, &rfb);
    483484
    484         errno_t rc = loc_server_register(NAME);
     485        errno_t rc = loc_server_register(NAME, &srv);
    485486        if (rc != EOK) {
    486487                printf("%s: Unable to register server.\n", NAME);
    … …  
    497498        service_id_t service_id;
    498499
    499         rc = loc_service_register(service_name, &service_id);
     500        rc = loc_service_register(srv, service_name, &service_id);
    500501        if (rc != EOK) {
    501502                printf(NAME ": Unable to register service %s.\n", service_name);
    … …  
    512513        }
    513514
    514         rc = loc_service_add_to_cat(service_id, ddev_cid);
     515        rc = loc_service_add_to_cat(srv, service_id, ddev_cid);
    515516        if (rc != EOK) {
    516517                fprintf(stderr, NAME ": Unable to add service to display device category.\n");

  • uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2010 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    8181int main(int argc, char *argv[])
    8282{
     83        loc_srv_t *srv;
     84
    8385        printf("%s: S3C24xx touchscreen driver\n", NAME);
    8486
    8587        async_set_fallback_port_handler(s3c24xx_ts_connection, NULL);
    86         errno_t rc = loc_server_register(NAME);
     88        errno_t rc = loc_server_register(NAME, &srv);
    8789        if (rc != EOK) {
    8890                printf("%s: Unable to register driver.\n", NAME);
    … …  
    9193
    9294        ts = malloc(sizeof(s3c24xx_ts_t));
    93         if (ts == NULL)
     95        if (ts == NULL) {
     96                loc_server_unregister(srv);
    9497                return -1;
    95 
    96         if (s3c24xx_ts_init(ts) != EOK)
     98        }
     99
     100        if (s3c24xx_ts_init(ts) != EOK) {
     101                free(ts);
     102                loc_server_unregister(srv);
    97103                return -1;
    98 
    99         rc = loc_service_register(NAMESPACE "/mouse", &ts->service_id);
     104        }
     105
     106        rc = loc_service_register(srv, NAMESPACE "/mouse", &ts->service_id);
    100107        if (rc != EOK) {
     108                // XXX s3c24xx_ts_fini();
     109                free(ts);
     110                loc_server_unregister(srv);
    101111                printf(NAME ": Unable to register device %s.\n",
    102112                    NAMESPACE "/mouse");

  • uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2010 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    8080int main(int argc, char *argv[])
    8181{
     82        loc_srv_t *srv;
     83
    8284        printf("%s: S3C24xx on-chip UART driver\n", NAME);
    8385
    8486        async_set_fallback_port_handler(s3c24xx_uart_connection, uart);
    85         errno_t rc = loc_server_register(NAME);
     87        errno_t rc = loc_server_register(NAME, &srv);
    8688        if (rc != EOK) {
    8789                printf("%s: Unable to register server.\n", NAME);
    … …  
    9092
    9193        uart = malloc(sizeof(s3c24xx_uart_t));
    92         if (uart == NULL)
    93                 return -1;
    94 
    95         if (s3c24xx_uart_init(uart) != EOK)
    96                 return -1;
    97 
    98         rc = loc_service_register(NAMESPACE "/" NAME, &uart->service_id);
     94        if (uart == NULL) {
     95                loc_server_unregister(srv);
     96                return -1;
     97        }
     98
     99        if (s3c24xx_uart_init(uart) != EOK) {
     100                free(uart);
     101                loc_server_unregister(srv);
     102                return -1;
     103        }
     104
     105        rc = loc_service_register(srv, NAMESPACE "/" NAME, &uart->service_id);
    99106        if (rc != EOK) {
     107                // XXX s3c24xx_uart_fini(uart);
     108                free(uart);
     109                loc_server_unregister(srv);
    100110                printf(NAME ": Unable to register device %s.\n",
    101111                    NAMESPACE "/" NAME);

  • uspace/srv/net/dhcp/main.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2013 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    5454static errno_t dhcp_init(void)
    5555{
     56        loc_srv_t *srv;
    5657        errno_t rc;
    5758
    … …  
    6869        async_set_fallback_port_handler(dhcp_client_conn, NULL);
    6970
    70         rc = loc_server_register(NAME);
     71        rc = loc_server_register(NAME, &srv);
    7172        if (rc != EOK) {
    7273                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server: %s.", str_error(rc));
    … …  
    7576
    7677        service_id_t sid;
    77         rc = loc_service_register(SERVICE_NAME_DHCP, &sid);
     78        rc = loc_service_register(srv, SERVICE_NAME_DHCP, &sid);
    7879        if (rc != EOK) {
     80                loc_server_unregister(srv);
    7981                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service: %s.", str_error(rc));
    8082                return EEXIST;

  • uspace/srv/net/dnsrsrv/dnsrsrv.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2013 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    5757static errno_t dnsr_init(void)
    5858{
     59        loc_srv_t *srv;
    5960        errno_t rc;
    6061        log_msg(LOG_DEFAULT, LVL_DEBUG, "dnsr_init()");
    … …  
    6869        async_set_fallback_port_handler(dnsr_client_conn, NULL);
    6970
    70         rc = loc_server_register(NAME);
     71        rc = loc_server_register(NAME, &srv);
    7172        if (rc != EOK) {
    7273                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server: %s.", str_error(rc));
    … …  
    7677
    7778        service_id_t sid;
    78         rc = loc_service_register(SERVICE_NAME_DNSR, &sid);
    79         if (rc != EOK) {
     79        rc = loc_service_register(srv, SERVICE_NAME_DNSR, &sid);
     80        if (rc != EOK) {
     81                loc_server_unregister(srv);
    8082                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service: %s.", str_error(rc));
    8183                transport_fini();

  • uspace/srv/net/ethip/ethip.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2021 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    7878};
    7979
     80static loc_srv_t *ethip_srv;
     81
    8082static errno_t ethip_init(void)
    8183{
    8284        async_set_fallback_port_handler(ethip_client_conn, NULL);
    8385
    84         errno_t rc = loc_server_register(NAME);
     86        errno_t rc = loc_server_register(NAME, &ethip_srv);
    8587        if (rc != EOK) {
    8688                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server.");
    … …  
    115117        }
    116118
    117         rc = loc_service_register(svc_name, &sid);
     119        rc = loc_service_register(ethip_srv, svc_name, &sid);
    118120        if (rc != EOK) {
    119121                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service %s.", svc_name);
    … …  
    129131        }
    130132
    131         rc = loc_service_add_to_cat(sid, iplink_cat);
     133        rc = loc_service_add_to_cat(ethip_srv, sid, iplink_cat);
    132134        if (rc != EOK) {
    133135                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding %s to category.", svc_name);

  • uspace/srv/net/inetsrv/inetsrv.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    8686static errno_t inet_init(void)
    8787{
     88        loc_srv_t *srv;
     89
    8890        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_init()");
    8991
    … …  
    104106                return rc;
    105107
    106         rc = loc_server_register(NAME);
     108        rc = loc_server_register(NAME, &srv);
    107109        if (rc != EOK) {
    108110                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server: %s.", str_error(rc));
    … …  
    111113
    112114        service_id_t sid;
    113         rc = loc_service_register(SERVICE_NAME_INET, &sid);
    114         if (rc != EOK) {
     115        rc = loc_service_register(srv, SERVICE_NAME_INET, &sid);
     116        if (rc != EOK) {
     117                loc_server_unregister(srv);
    115118                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service: %s.", str_error(rc));
    116119                return EEXIST;

  • uspace/srv/net/loopip/loopip.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2021 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    103103static errno_t loopip_init(void)
    104104{
     105        loc_srv_t *srv;
     106
    105107        async_set_fallback_port_handler(loopip_client_conn, NULL);
    106108
    107         errno_t rc = loc_server_register(NAME);
     109        errno_t rc = loc_server_register(NAME, &srv);
    108110        if (rc != EOK) {
    109111                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server.");
    … …  
    119121        const char *svc_name = "net/loopback";
    120122        service_id_t sid;
    121         rc = loc_service_register(svc_name, &sid);
    122         if (rc != EOK) {
     123        rc = loc_service_register(srv, svc_name, &sid);
     124        if (rc != EOK) {
     125                loc_server_unregister(srv);
    123126                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service %s.",
    124127                    svc_name);
    … …  
    129132        rc = loc_category_get_id("iplink", &iplink_cat, IPC_FLAG_BLOCKING);
    130133        if (rc != EOK) {
     134                loc_service_unregister(srv, sid);
     135                loc_server_unregister(srv);
    131136                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'iplink'.");
    132137                return rc;
    133138        }
    134139
    135         rc = loc_service_add_to_cat(sid, iplink_cat);
    136         if (rc != EOK) {
     140        rc = loc_service_add_to_cat(srv, sid, iplink_cat);
     141        if (rc != EOK) {
     142                loc_service_unregister(srv, sid);
     143                loc_server_unregister(srv);
    137144                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding %s to category.",
    138145                    svc_name);
    … …  
    141148
    142149        fid_t fid = fibril_create(loopip_recv_fibril, NULL);
    143         if (fid == 0)
    144                 return ENOMEM;
     150        if (fid == 0) {
     151                loc_service_unregister(srv, sid);
     152                loc_server_unregister(srv);
     153                return ENOMEM;
     154        }
    145155
    146156        fibril_add_ready(fid);

  • uspace/srv/net/nconfsrv/nconfsrv.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2013 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    5959{
    6060        service_id_t sid;
     61        loc_srv_t *srv;
    6162        errno_t rc;
    6263
    … …  
    7980        async_set_fallback_port_handler(ncs_client_conn, NULL);
    8081
    81         rc = loc_server_register(NAME);
     82        rc = loc_server_register(NAME, &srv);
    8283        if (rc != EOK) {
    8384                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server: %s.", str_error(rc));
    … …  
    8586        }
    8687
    87         rc = loc_service_register(SERVICE_NAME_NETCONF, &sid);
     88        rc = loc_service_register(srv, SERVICE_NAME_NETCONF, &sid);
    8889        if (rc != EOK) {
     90                loc_server_unregister(srv);
    8991                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service: %s.", str_error(rc));
    9092                return EEXIST;
    … …  
    9294
    9395        rc = ncs_link_discovery_start();
    94         if (rc != EOK)
     96        if (rc != EOK) {
     97                loc_service_unregister(srv, sid);
     98                loc_server_unregister(srv);
    9599                return EEXIST;
     100        }
    96101
    97102        return EOK;

  • uspace/srv/net/slip/slip.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2021 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * Copyright (c) 2013 Jakub Jermar
    44 * All rights reserved.
    … …  
    307307        chardev_t *chardev_out = NULL;
    308308        fid_t fid;
     309        loc_srv_t *srv;
    309310        errno_t rc;
    310311
    … …  
    314315        async_set_fallback_port_handler(slip_client_conn, NULL);
    315316
    316         rc = loc_server_register(NAME);
     317        rc = loc_server_register(NAME, &srv);
    317318        if (rc != EOK) {
    318319                log_msg(LOG_DEFAULT, LVL_ERROR,
    … …  
    323324        rc = loc_service_get_id(svcstr, &svcid, 0);
    324325        if (rc != EOK) {
     326                loc_server_unregister(srv);
    325327                log_msg(LOG_DEFAULT, LVL_ERROR,
    326328                    "Failed getting ID for service %s", svcstr);
    … …  
    330332        rc = loc_category_get_id(CAT_IPLINK, &iplinkcid, 0);
    331333        if (rc != EOK) {
     334                loc_server_unregister(srv);
    332335                log_msg(LOG_DEFAULT, LVL_ERROR,
    333336                    "Failed to get category ID for %s",
    … …  
    342345        sess_out = loc_service_connect(svcid, INTERFACE_DDF, 0);
    343346        if (!sess_out) {
     347                loc_server_unregister(srv);
    344348                log_msg(LOG_DEFAULT, LVL_ERROR,
    345349                    "Failed to connect to service %s (ID=%d)",
    … …  
    350354        rc = chardev_open(sess_out, &chardev_out);
    351355        if (rc != EOK) {
     356                loc_server_unregister(srv);
    352357                log_msg(LOG_DEFAULT, LVL_ERROR,
    353358                    "Failed opening character device.");
    … …  
    373378        }
    374379
    375         rc = loc_service_register(linkstr, &linksid);
     380        rc = loc_service_register(srv, linkstr, &linksid);
    376381        if (rc != EOK) {
    377382                log_msg(LOG_DEFAULT, LVL_ERROR,
    … …  
    381386        }
    382387
    383         rc = loc_service_add_to_cat(linksid, iplinkcid);
    384         if (rc != EOK) {
     388        rc = loc_service_add_to_cat(srv, linksid, iplinkcid);
     389        if (rc != EOK) {
     390                loc_service_unregister(srv, linksid);
    385391                log_msg(LOG_DEFAULT, LVL_ERROR,
    386392                    "Failed to add service %d (%s) to category %d (%s).",
    … …  
    401407
    402408fail:
     409        loc_server_unregister(srv);
    403410        chardev_close(chardev_out);
    404411        if (sess_out)

  • uspace/srv/net/tcp/service.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2015 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    12421242        errno_t rc;
    12431243        service_id_t sid;
     1244        loc_srv_t *srv;
    12441245
    12451246        async_set_fallback_port_handler(tcp_client_conn, NULL);
    12461247
    1247         rc = loc_server_register(NAME);
     1248        rc = loc_server_register(NAME, &srv);
    12481249        if (rc != EOK) {
    12491250                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server.");
    … …  
    12511252        }
    12521253
    1253         rc = loc_service_register(SERVICE_NAME_TCP, &sid);
    1254         if (rc != EOK) {
     1254        rc = loc_service_register(srv, SERVICE_NAME_TCP, &sid);
     1255        if (rc != EOK) {
     1256                loc_server_unregister(srv);
    12551257                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service.");
    12561258                return EIO;

  • uspace/srv/net/udp/service.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2015 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    647647        errno_t rc;
    648648        service_id_t sid;
     649        loc_srv_t *srv;
    649650
    650651        async_set_fallback_port_handler(udp_client_conn, NULL);
    651652
    652         rc = loc_server_register(NAME);
     653        rc = loc_server_register(NAME, &srv);
    653654        if (rc != EOK) {
    654655                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server.");
    … …  
    656657        }
    657658
    658         rc = loc_service_register(SERVICE_NAME_UDP, &sid);
    659         if (rc != EOK) {
     659        rc = loc_service_register(srv, SERVICE_NAME_UDP, &sid);
     660        if (rc != EOK) {
     661                loc_server_unregister(srv);
    660662                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service.");
    661663                return EIO;

  • uspace/srv/taskmon/taskmon.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2013 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    136136int main(int argc, char *argv[])
    137137{
     138        loc_srv_t *srv;
     139
    138140        printf("%s: Task Monitoring Service\n", NAME);
    139141
    … …  
    150152        async_set_fallback_port_handler(corecfg_client_conn, NULL);
    151153
    152         errno_t rc = loc_server_register(NAME);
     154        errno_t rc = loc_server_register(NAME, &srv);
    153155        if (rc != EOK) {
    154156                printf("%s: Failed registering server: %s.\n",
    … …  
    158160
    159161        service_id_t sid;
    160         rc = loc_service_register(SERVICE_NAME_CORECFG, &sid);
     162        rc = loc_service_register(srv, SERVICE_NAME_CORECFG, &sid);
    161163        if (rc != EOK) {
     164                loc_server_unregister(srv);
    162165                printf("%s: Failed registering service: %s.\n",
    163166                    NAME, str_error(rc));

  • uspace/srv/test/chardev-test/main.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2017 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    118118{
    119119        errno_t rc;
     120        loc_srv_t *srv;
    120121
    121122        printf("%s: Character device test service\n", NAME);
    122123        async_set_fallback_port_handler(chardev_test_connection, NULL);
    123124
    124         rc = loc_server_register(NAME);
     125        rc = loc_server_register(NAME, &srv);
    125126        if (rc != EOK) {
    126127                printf("%s: Failed registering server.: %s\n", NAME, str_error(rc));
    … …  
    140141        partialx_srvs.sarg = NULL;
    141142
    142         rc = loc_service_register(SERVICE_NAME_CHARDEV_TEST_SMALLX, &smallx_svc_id);
     143        rc = loc_service_register(srv, SERVICE_NAME_CHARDEV_TEST_SMALLX,
     144            &smallx_svc_id);
    143145        if (rc != EOK) {
    144146                printf("%s: Failed registering service.: %s\n", NAME, str_error(rc));
    145                 return rc;
    146         }
    147 
    148         rc = loc_service_register(SERVICE_NAME_CHARDEV_TEST_LARGEX, &largex_svc_id);
     147                goto error;
     148        }
     149
     150        rc = loc_service_register(srv, SERVICE_NAME_CHARDEV_TEST_LARGEX,
     151            &largex_svc_id);
    149152        if (rc != EOK) {
    150153                printf("%s: Failed registering service.: %s\n", NAME, str_error(rc));
    151                 return rc;
    152         }
    153 
    154         rc = loc_service_register(SERVICE_NAME_CHARDEV_TEST_PARTIALX, &partialx_svc_id);
     154                goto error;
     155        }
     156
     157        rc = loc_service_register(srv, SERVICE_NAME_CHARDEV_TEST_PARTIALX,
     158            &partialx_svc_id);
    155159        if (rc != EOK) {
    156160                printf("%s: Failed registering service.: %s\n", NAME, str_error(rc));
    157                 return rc;
     161                goto error;
    158162        }
    159163
    … …  
    164168        /* Not reached */
    165169        return 0;
     170error:
     171        if (smallx_svc_id != 0)
     172                loc_service_unregister(srv, smallx_svc_id);
     173        if (largex_svc_id != 0)
     174                loc_service_unregister(srv, largex_svc_id);
     175        if (partialx_svc_id != 0)
     176                loc_service_unregister(srv, partialx_svc_id);
     177        loc_server_unregister(srv);
     178        return rc;
    166179}
    167180

  • uspace/srv/test/ipc-test/main.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2018 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    222222{
    223223        errno_t rc;
     224        loc_srv_t *srv;
    224225
    225226        printf("%s: IPC test service\n", NAME);
    … …  
    232233        }
    233234
    234         rc = loc_server_register(NAME);
     235        rc = loc_server_register(NAME, &srv);
    235236        if (rc != EOK) {
    236237                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server. (%s)\n",
    … …  
    239240        }
    240241
    241         rc = loc_service_register(SERVICE_NAME_IPC_TEST, &svc_id);
    242         if (rc != EOK) {
     242        rc = loc_service_register(srv, SERVICE_NAME_IPC_TEST, &svc_id);
     243        if (rc != EOK) {
     244                loc_server_unregister(srv);
    243245                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service. (%s)\n",
    244246                    str_error(rc));

  • uspace/srv/volsrv/volsrv.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2015 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    6262        vol_volumes_t *volumes = NULL;
    6363        vol_parts_t *parts = NULL;
     64        loc_srv_t *srv = NULL;
    6465
    6566        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_init()");
    … …  
    7980        async_set_fallback_port_handler(vol_client_conn, parts);
    8081
    81         rc = loc_server_register(NAME);
     82        rc = loc_server_register(NAME, &srv);
    8283        if (rc != EOK) {
    8384                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server: %s.", str_error(rc));
    … …  
    8687
    8788        service_id_t sid;
    88         rc = loc_service_register(SERVICE_NAME_VOLSRV, &sid);
     89        rc = loc_service_register(srv, SERVICE_NAME_VOLSRV, &sid);
    8990        if (rc != EOK) {
    9091                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service: %s.", str_error(rc));
    … …  
    9596        return EOK;
    9697error:
     98        if (srv != NULL)
     99                loc_server_unregister(srv);
    97100        vol_volumes_destroy(volumes);
    98101        vol_parts_destroy(parts);
Note: See TracChangeset for help on using the changeset viewer.