Changeset dc5c303 in mainline for uspace/srv


Ignore:
Timestamp:
2023-12-28T13:59:23Z (22 months ago)
Author:
GitHub <noreply@…>
Children:
6b66de6b
Parents:
42c2e65 (diff), f87ff8e (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.
git-author:
boba-buba <120932204+boba-buba@…> (2023-12-28 13:59:23)
git-committer:
GitHub <noreply@…> (2023-12-28 13:59:23)
Message:

Merge branch 'master' into topic/packet-capture

Location:
uspace/srv
Files:
52 edited

Legend:

Unmodified
Added
Removed

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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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/clipboard/meson.build

    r42c2e65 rdc5c303  
    11#
     2# Copyright (c) 2023 Jiri Svoboda
    23# Copyright (c) 2005 Martin Decky
    34# Copyright (c) 2007 Jakub Jermar
    … …  
    2829#
    2930
     31deps = [ 'clipboard' ]
    3032src = files('clipboard.c')

  • uspace/srv/devman/drv_conn.c

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    11/*
    2  * Copyright (c) 2022 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * Copyright (c) 2011 Martin Decky
    44 * All rights reserved.
    … …  
    3737#include <stdio.h>
    3838#include <adt/prodcons.h>
     39#include <io/console.h>
    3940#include <io/input.h>
    4041#include <ipc/vfs.h>
    … …  
    8889        con_srvs_t srvs;         /**< Console service setup */
    8990} console_t;
     91
     92static loc_srv_t *console_srv;
    9093
    9194/** Input server proxy */
    … …  
    902905        /* Register server */
    903906        async_set_fallback_port_handler(client_connection, NULL);
    904         rc = loc_server_register(NAME);
     907        rc = loc_server_register(NAME, &console_srv);
    905908        if (rc != EOK) {
    906909                printf("%s: Unable to register server (%s)\n", NAME,
    … …  
    952955                        snprintf(vc, LOC_NAME_MAXLEN, "%s/vc%zu", NAMESPACE, i);
    953956
    954                         if (loc_service_register(vc, &consoles[i].dsid) != EOK) {
     957                        if (loc_service_register(console_srv, vc,
     958                            &consoles[i].dsid) != EOK) {
    955959                                printf("%s: Unable to register device %s\n", NAME, vc);
    956960                                return false;

  • uspace/srv/hid/console/meson.build

    r42c2e65 rdc5c303  
    2828#
    2929
     30deps = [ 'console', 'input', 'output' ]
    3031src = files('console.c')

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

    r42c2e65 rdc5c303  
    5050static errno_t dispc_dev_assign(void *, sysarg_t, sysarg_t);
    5151static errno_t dispc_dev_unassign(void *, sysarg_t);
     52static errno_t dispc_get_asgn_dev_list(void *, sysarg_t, dispcfg_dev_list_t **);
    5253static errno_t dispc_get_event(void *, dispcfg_ev_t *);
    5354
    … …  
    5960        .dev_assign = dispc_dev_assign,
    6061        .dev_unassign = dispc_dev_unassign,
     62        .get_asgn_dev_list = dispc_get_asgn_dev_list,
    6163        .get_event = dispc_get_event,
    6264};
    … …  
    195197        ds_cfgclient_t *cfgclient = (ds_cfgclient_t *)arg;
    196198        ds_seat_t *seat;
     199        ds_seat_t *s;
    197200
    198201        log_msg(LOG_DEFAULT, LVL_DEBUG, "dispcfg_seat_delete()");
    … …  
    203206                ds_display_unlock(cfgclient->display);
    204207                return ENOENT;
     208        }
     209
     210        /* Verify we are not deleting the last seat */
     211        s = ds_display_first_seat(cfgclient->display);
     212        if (s == seat && ds_display_next_seat(s) == NULL) {
     213                ds_display_unlock(cfgclient->display);
     214                return EBUSY;
    205215        }
    206216
    … …  
    281291}
    282292
     293/** Get assigned device list.
     294 *
     295 * @param arg Argument (CFG client)
     296 * @param seat_id Seat ID
     297 * @param rlist Place to store pointer to new list
     298 * @return EOK on success or an error code
     299 */
     300static errno_t dispc_get_asgn_dev_list(void *arg, sysarg_t seat_id,
     301    dispcfg_dev_list_t **rlist)
     302{
     303        ds_cfgclient_t *cfgclient = (ds_cfgclient_t *)arg;
     304        dispcfg_dev_list_t *list;
     305        ds_seat_t *seat;
     306        ds_idevcfg_t *idevcfg;
     307        unsigned i;
     308
     309        log_msg(LOG_DEFAULT, LVL_DEBUG, "dispcfg_get_asgn_dev_list()");
     310
     311        list = calloc(1, sizeof(dispcfg_dev_list_t));
     312        if (list == NULL)
     313                return ENOMEM;
     314
     315        ds_display_lock(cfgclient->display);
     316
     317        seat = ds_display_find_seat(cfgclient->display, seat_id);
     318        if (seat == NULL) {
     319                ds_display_unlock(cfgclient->display);
     320                free(list);
     321                return ENOENT;
     322        }
     323
     324        /* Count the number of devices */
     325        list->ndevs = 0;
     326        idevcfg = ds_seat_first_idevcfg(seat);
     327        while (idevcfg != NULL) {
     328                ++list->ndevs;
     329                idevcfg = ds_display_next_idevcfg(idevcfg);
     330        }
     331
     332        /* Allocate array for device IDs */
     333        list->devs = calloc(list->ndevs, sizeof(sysarg_t));
     334        if (list->devs == NULL) {
     335                ds_display_unlock(cfgclient->display);
     336                free(list);
     337                return ENOMEM;
     338        }
     339
     340        /* Fill in device IDs */
     341        i = 0;
     342        idevcfg = ds_seat_first_idevcfg(seat);
     343        while (idevcfg != NULL) {
     344                list->devs[i++] = idevcfg->svc_id;
     345                idevcfg = ds_display_next_idevcfg(idevcfg);
     346        }
     347
     348        ds_display_unlock(cfgclient->display);
     349        *rlist = list;
     350        return EOK;
     351}
     352
    283353/** Get display configuration event.
    284354 *

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

    r42c2e65 rdc5c303  
    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/display/meson.build

    r42c2e65 rdc5c303  
    2727#
    2828
    29 deps = [ 'ipcgfx', 'memgfx', 'display', 'ddev', 'dispcfg', 'wndmgt' ]
     29deps = [ 'ipcgfx', 'memgfx', 'display', 'ddev', 'dispcfg', 'wndmgt', 'input' ]
    3030
    3131src = files(

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

    r42c2e65 rdc5c303  
    8888        seat->client_cursor = display->cursor[dcurs_arrow];
    8989        seat->wm_cursor = NULL;
     90        seat->focus = ds_display_first_window(display);
    9091
    9192        *rseat = seat;
    … …  
    204205
    205206        /* Find alternate window that is neither system nor minimized */
    206         nwnd = ds_window_find_alt(wnd, ~(wndf_minimized | wndf_system));
     207        nwnd = ds_window_find_prev(wnd, ~(wndf_minimized | wndf_system));
    207208
    208209        if (nwnd == NULL) {
    209210                /* Find alternate window that is not minimized */
    210                 nwnd = ds_window_find_alt(wnd, ~wndf_minimized);
     211                nwnd = ds_window_find_prev(wnd, ~wndf_minimized);
    211212        }
    212213
    … …  
    223224        ds_window_t *nwnd;
    224225
    225         /* Find alternate window that is not a system window */
    226         nwnd = ds_window_find_alt(seat->focus, ~wndf_system);
     226        if (seat->focus != NULL) {
     227                /* Find alternate window that is not a system window */
     228                nwnd = ds_window_find_next(seat->focus, ~wndf_system);
     229        } else {
     230                /* Currently no focus. Focus topmost window. */
     231                nwnd = ds_display_first_window(seat->display);
     232        }
    227233
    228234        /* Only switch focus if there is another window */
    … …  
    509515        wnd = ds_display_window_by_pos(seat->display, &seat->pntpos);
    510516
    511         /* Click outside popup window */
    512         if (event->type == POS_PRESS && wnd != seat->popup) {
    513                 /* Close popup window */
    514                 ds_seat_set_popup(seat, NULL);
    515         }
    516 
    517517        /* Deliver event to popup window. */
    518         if (seat->popup != NULL) {
     518        if (seat->popup != NULL && event->type != POS_PRESS) {
    519519                rc = ds_window_post_pos_event(seat->popup, event);
    520520                if (rc != EOK)
    … …  
    540540                 * to the same window above.
    541541                 */
    542                 if (wnd != seat->popup) {
     542                if (wnd != seat->popup || event->type == POS_PRESS) {
    543543                        rc = ds_window_post_pos_event(wnd, event);
    544544                        if (rc != EOK)
    … …  
    550550        }
    551551
     552        /* Click outside popup window */
     553        if (event->type == POS_PRESS && wnd != seat->popup) {
     554                /* Close popup window */
     555                ds_seat_set_popup(seat, NULL);
     556        }
     557
    552558        return EOK;
    553559}

  • uspace/srv/hid/display/test/seat.c

    r42c2e65 rdc5c303  
    212212        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    213213
     214        /* w0 is at the top, then w1, then w2 */
     215
    214216        PCUT_ASSERT_EQUALS(w0, seat->focus);
    215217
    216218        ds_window_unfocus(w0);
    217219
    218         /* The previous window, w2, should be focused now */
    219         PCUT_ASSERT_EQUALS(w2, seat->focus);
     220        /* The previous window, w1, should be focused now */
     221        PCUT_ASSERT_EQUALS(w1, seat->focus);
    220222
    221223        ds_window_destroy(w0);

  • uspace/srv/hid/display/test/window.c

    r42c2e65 rdc5c303  
    11091109        PCUT_ASSERT_EQUALS(wnd->display->cursor[dcurs_arrow], wnd->cursor);
    11101110
     1111        // Check that invalid cursors cannot be set: ignore enum conversions
     1112        // as we are out-of-bounds
     1113#pragma GCC diagnostic push
     1114#if defined(__GNUC__) && (__GNUC__ >= 10)
     1115#pragma GCC diagnostic ignored "-Wenum-conversion"
     1116#endif
    11111117        rc = ds_window_set_cursor(wnd, dcurs_limit);
    11121118        PCUT_ASSERT_ERRNO_VAL(EINVAL, rc);
    … …  
    11161122        PCUT_ASSERT_ERRNO_VAL(EINVAL, rc);
    11171123        PCUT_ASSERT_EQUALS(wnd->display->cursor[dcurs_arrow], wnd->cursor);
     1124#pragma GCC diagnostic pop
    11181125
    11191126        rc = ds_window_set_cursor(wnd, dcurs_size_lr);
    … …  
    11691176}
    11701177
    1171 /** ds_window_find_alt() finds alternate window by flags */
    1172 PCUT_TEST(window_find_alt)
     1178/** ds_window_find_next() finds next window by flags */
     1179PCUT_TEST(window_find_next)
    11731180{
    11741181        gfx_context_t *gc;
    … …  
    12101217        w2->flags |= wndf_system;
    12111218
    1212         wnd = ds_window_find_alt(w0, wndf_minimized);
     1219        wnd = ds_window_find_next(w0, wndf_minimized);
    12131220        PCUT_ASSERT_EQUALS(w1, wnd);
    12141221
    1215         wnd = ds_window_find_alt(w0, wndf_system);
     1222        wnd = ds_window_find_next(w0, wndf_system);
    12161223        PCUT_ASSERT_EQUALS(w2, wnd);
    12171224
    1218         wnd = ds_window_find_alt(w0, wndf_maximized);
     1225        wnd = ds_window_find_next(w0, wndf_maximized);
     1226        PCUT_ASSERT_NULL(wnd);
     1227
     1228        ds_window_destroy(w0);
     1229        ds_window_destroy(w1);
     1230        ds_window_destroy(w2);
     1231        ds_seat_destroy(seat);
     1232        ds_client_destroy(client);
     1233        ds_display_destroy(disp);
     1234}
     1235
     1236/** ds_window_find_prev() finds previous window by flags */
     1237PCUT_TEST(window_find_prev)
     1238{
     1239        gfx_context_t *gc;
     1240        ds_display_t *disp;
     1241        ds_client_t *client;
     1242        ds_seat_t *seat;
     1243        ds_window_t *w0;
     1244        ds_window_t *w1;
     1245        ds_window_t *w2;
     1246        ds_window_t *wnd;
     1247        display_wnd_params_t params;
     1248        errno_t rc;
     1249
     1250        rc = gfx_context_new(&dummy_ops, NULL, &gc);
     1251        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1252
     1253        rc = ds_display_create(gc, df_none, &disp);
     1254        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1255
     1256        rc = ds_client_create(disp, NULL, NULL, &client);
     1257        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1258
     1259        rc = ds_seat_create(disp, "Alice", &seat);
     1260        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1261
     1262        display_wnd_params_init(&params);
     1263        params.rect.p0.x = params.rect.p0.y = 0;
     1264        params.rect.p1.x = params.rect.p1.y = 1;
     1265
     1266        rc = ds_window_create(client, &params, &w2);
     1267        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1268        w2->flags |= wndf_system;
     1269
     1270        rc = ds_window_create(client, &params, &w1);
     1271        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1272        w1->flags |= wndf_minimized;
     1273
     1274        rc = ds_window_create(client, &params, &w0);
     1275        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1276
     1277        wnd = ds_window_find_prev(w0, wndf_minimized);
     1278        PCUT_ASSERT_EQUALS(w1, wnd);
     1279
     1280        wnd = ds_window_find_prev(w0, wndf_system);
     1281        PCUT_ASSERT_EQUALS(w2, wnd);
     1282
     1283        wnd = ds_window_find_prev(w0, wndf_maximized);
    12191284        PCUT_ASSERT_NULL(wnd);
    12201285

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

    r42c2e65 rdc5c303  
    9595        }
    9696
     97        wnd->flags = params->flags;
     98
    9799        ds_client_add_window(client, wnd);
    98100        ds_display_add_window(client->display, wnd);
    … …  
    134136        wnd->gc = mem_gc_get_ctx(wnd->mgc);
    135137        wnd->cursor = wnd->display->cursor[dcurs_arrow];
    136         wnd->flags = params->flags;
    137138
    138139        if ((params->flags & wndf_setpos) != 0) {
    … …  
    10921093 * @return Alternate window matching the criteria or @c NULL if there is none
    10931094 */
    1094 ds_window_t *ds_window_find_alt(ds_window_t *wnd,
     1095ds_window_t *ds_window_find_prev(ds_window_t *wnd,
     1096    display_wnd_flags_t allowed_flags)
     1097{
     1098        ds_window_t *nwnd;
     1099
     1100        /* Try preceding windows in display order */
     1101        nwnd = ds_display_next_window(wnd);
     1102        while (nwnd != NULL && (nwnd->flags & ~allowed_flags) != 0) {
     1103                nwnd = ds_display_next_window(nwnd);
     1104        }
     1105
     1106        /* Do we already have a matching window? */
     1107        if (nwnd != NULL && (nwnd->flags & ~allowed_flags) == 0) {
     1108                return nwnd;
     1109        }
     1110
     1111        /* Try succeeding windows in display order */
     1112        nwnd = ds_display_first_window(wnd->display);
     1113        while (nwnd != NULL && nwnd != wnd &&
     1114            (nwnd->flags & ~allowed_flags) != 0) {
     1115                nwnd = ds_display_next_window(nwnd);
     1116        }
     1117
     1118        if (nwnd == wnd)
     1119                return NULL;
     1120
     1121        return nwnd;
     1122}
     1123
     1124/** Find alternate window with the allowed flags.
     1125 *
     1126 * An alternate window is a *different* window that is preferably previous
     1127 * in the display order and only has the @a allowed flags.
     1128 *
     1129 * @param wnd Window
     1130 * @param allowed_flags Bitmask of flags that the window is allowed to have
     1131 *
     1132 * @return Alternate window matching the criteria or @c NULL if there is none
     1133 */
     1134ds_window_t *ds_window_find_next(ds_window_t *wnd,
    10951135    display_wnd_flags_t allowed_flags)
    10961136{

  • uspace/srv/hid/display/window.h

    r42c2e65 rdc5c303  
    7878extern errno_t ds_window_set_cursor(ds_window_t *, display_stock_cursor_t);
    7979extern errno_t ds_window_set_caption(ds_window_t *, const char *);
    80 extern ds_window_t *ds_window_find_alt(ds_window_t *, display_wnd_flags_t);
     80extern ds_window_t *ds_window_find_next(ds_window_t *, display_wnd_flags_t);
     81extern ds_window_t *ds_window_find_prev(ds_window_t *, display_wnd_flags_t);
    8182extern void ds_window_unfocus(ds_window_t *);
    8283extern bool ds_window_orig_seat(ds_window_t *, sysarg_t);

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

    r42c2e65 rdc5c303  
    11/*
    2  * Copyright (c) 2011 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    228228        0,      KC_RIGHT,       0x1b, 0x5b, 0x43, GSP_END,
    229229
     230        /* Ctrl + key */
     231
    230232        KM_CTRL,        KC_Q,           0x11, GSP_END,
    231233        KM_CTRL,        KC_W,           0x17, GSP_END,
    … …  
    253255        KM_CTRL,        KC_N,           0x0e, GSP_END,
    254256
     257        /* Alt + key */
     258
     259        KM_ALT, KC_BACKTICK,    0x1b, 0x60, GSP_END,
     260
     261        KM_ALT, KC_1,           0x1b, 0x31, GSP_END,
     262        KM_ALT, KC_2,           0x1b, 0x32, GSP_END,
     263        KM_ALT, KC_3,           0x1b, 0x33, GSP_END,
     264        KM_ALT, KC_4,           0x1b, 0x34, GSP_END,
     265        KM_ALT, KC_5,           0x1b, 0x35, GSP_END,
     266        KM_ALT, KC_6,           0x1b, 0x36, GSP_END,
     267        KM_ALT, KC_7,           0x1b, 0x37, GSP_END,
     268        KM_ALT, KC_8,           0x1b, 0x38, GSP_END,
     269        KM_ALT, KC_9,           0x1b, 0x39, GSP_END,
     270        KM_ALT, KC_0,           0x1b, 0x30, GSP_END,
     271
     272        KM_ALT, KC_MINUS,       0x1b, 0x2d, GSP_END,
     273        KM_ALT, KC_EQUALS,      0x1b, 0x3d, GSP_END,
     274
     275        KM_ALT, KC_Q,           0x1b, 0x71, GSP_END,
     276        KM_ALT, KC_W,           0x1b, 0x77, GSP_END,
     277        KM_ALT, KC_E,           0x1b, 0x65, GSP_END,
     278        KM_ALT, KC_R,           0x1b, 0x72, GSP_END,
     279        KM_ALT, KC_T,           0x1b, 0x74, GSP_END,
     280        KM_ALT, KC_Y,           0x1b, 0x79, GSP_END,
     281        KM_ALT, KC_U,           0x1b, 0x75, GSP_END,
     282        KM_ALT, KC_I,           0x1b, 0x69, GSP_END,
     283        KM_ALT, KC_O,           0x1b, 0x6f, GSP_END,
     284        KM_ALT, KC_P,           0x1b, 0x70, GSP_END,
     285
     286        /* 0x1b, 0x5b is used by other keys/sequences */
     287        KM_ALT, KC_RBRACKET,    0x1b, 0x5d, GSP_END,
     288
     289        KM_ALT, KC_A,           0x1b, 0x61, GSP_END,
     290        KM_ALT, KC_S,           0x1b, 0x73, GSP_END,
     291        KM_ALT, KC_D,           0x1b, 0x64, GSP_END,
     292        KM_ALT, KC_F,           0x1b, 0x66, GSP_END,
     293        KM_ALT, KC_G,           0x1b, 0x67, GSP_END,
     294        KM_ALT, KC_H,           0x1b, 0x68, GSP_END,
     295        KM_ALT, KC_J,           0x1b, 0x6a, GSP_END,
     296        KM_ALT, KC_K,           0x1b, 0x6b, GSP_END,
     297        KM_ALT, KC_L,           0x1b, 0x6c, GSP_END,
     298
     299        KM_ALT, KC_SEMICOLON,   0x1b, 0x3b, GSP_END,
     300        KM_ALT, KC_QUOTE,       0x1b, 0x27, GSP_END,
     301        KM_ALT, KC_BACKSLASH,   0x1b, 0x5c, GSP_END,
     302
     303        KM_ALT, KC_Z,           0x1b, 0x7a, GSP_END,
     304        KM_ALT, KC_X,           0x1b, 0x78, GSP_END,
     305        KM_ALT, KC_C,           0x1b, 0x63, GSP_END,
     306        KM_ALT, KC_V,           0x1b, 0x76, GSP_END,
     307        KM_ALT, KC_B,           0x1b, 0x62, GSP_END,
     308        KM_ALT, KC_N,           0x1b, 0x6e, GSP_END,
     309        KM_ALT, KC_M,           0x1b, 0x6d, GSP_END,
     310
     311        KM_ALT, KC_COMMA,       0x1b, 0x2c, GSP_END,
     312        KM_ALT, KC_PERIOD,      0x1b, 0x2e, GSP_END,
     313        KM_ALT, KC_SLASH,       0x1b, 0x2f, GSP_END,
     314
    255315        /*
    256316         * Sequences specific to Gnome terminal

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

    r42c2e65 rdc5c303  
    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/input/meson.build

    r42c2e65 rdc5c303  
    2828#
    2929
    30 deps = [ 'drv' ]
     30deps = [ 'drv', 'console', 'input' ]
    3131src = files(
    3232        'layout/cz.c',

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

    r42c2e65 rdc5c303  
    11/*
    2  * Copyright (c) 2011 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4747/** Correspondence between modifers and the modifier keycodes. */
    4848static unsigned int mods_keys[][2] = {
     49        { KM_LALT, KC_LALT },
    4950        { KM_LSHIFT, KC_LSHIFT },
    5051        { KM_LCTRL, KC_LCTRL },

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

    r42c2e65 rdc5c303  
    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/isdv4_tablet/meson.build

    r42c2e65 rdc5c303  
    2727#
    2828
    29 deps = [ 'drv' ]
     29deps = [ 'drv', 'input' ]
    3030src = files('main.c', 'isdv4.c')

  • uspace/srv/hid/output/meson.build

    r42c2e65 rdc5c303  
    2828#
    2929
    30 deps = [ 'codepage', 'drv', 'fbfont', 'pixconv', 'ddev' ]
     30deps = [ 'codepage', 'console', 'drv', 'fbfont', 'pixconv', 'ddev', 'output' ]
    3131src = files(
    3232        'ctl/serial.c',

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

    r42c2e65 rdc5c303  
    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/output/proto/vt100.c

    r42c2e65 rdc5c303  
    4141#include "vt100.h"
    4242
    43 #define MAX_CONTROL  20
     43/** Buffer size when creating actual VT100 commands.
     44 *
     45 * This is absurdly large but since we accept numbers via sysarg_t,
     46 * we make it big enough for the largest value to be on the safe side
     47 * (and to silence compiler too).
     48 *
     49 * TODO: find out if VT100 has some hard limits or perhaps simply cut-out
     50 * values larger than 16 bits or something.
     51 */
     52#define MAX_CONTROL 64
    4453
    4554typedef enum {

  • uspace/srv/hid/remcons/meson.build

    r42c2e65 rdc5c303  
    2828#
    2929
    30 deps = [ 'inet' ]
     30deps = [ 'inet', 'console' ]
    3131src = files('remcons.c', 'user.c')

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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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/meson.build

    r42c2e65 rdc5c303  
    2727#
    2828
     29deps = [ 'input' ]
    2930src = files('s3c24xx_ts.c')

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

    r42c2e65 rdc5c303  
    11/*
    2  * Copyright (c) 2010 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3939#include <ddi.h>
    4040#include <loc.h>
    41 #include <io/console.h>
    4241#include <vfs/vfs.h>
    4342#include <ipc/mouseev.h>
    … …  
    8180int main(int argc, char *argv[])
    8281{
     82        loc_srv_t *srv;
     83
    8384        printf("%s: S3C24xx touchscreen driver\n", NAME);
    8485
    8586        async_set_fallback_port_handler(s3c24xx_ts_connection, NULL);
    86         errno_t rc = loc_server_register(NAME);
     87        errno_t rc = loc_server_register(NAME, &srv);
    8788        if (rc != EOK) {
    8889                printf("%s: Unable to register driver.\n", NAME);
    … …  
    9192
    9293        ts = malloc(sizeof(s3c24xx_ts_t));
    93         if (ts == NULL)
     94        if (ts == NULL) {
     95                loc_server_unregister(srv);
    9496                return -1;
    95 
    96         if (s3c24xx_ts_init(ts) != EOK)
     97        }
     98
     99        if (s3c24xx_ts_init(ts) != EOK) {
     100                free(ts);
     101                loc_server_unregister(srv);
    97102                return -1;
    98 
    99         rc = loc_service_register(NAMESPACE "/mouse", &ts->service_id);
     103        }
     104
     105        rc = loc_service_register(srv, NAMESPACE "/mouse", &ts->service_id);
    100106        if (rc != EOK) {
     107                // XXX s3c24xx_ts_fini();
     108                free(ts);
     109                loc_server_unregister(srv);
    101110                printf(NAME ": Unable to register device %s.\n",
    102111                    NAMESPACE "/mouse");

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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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/meson.build

    r42c2e65 rdc5c303  
    11#
    2 # Copyright (c) 2010 Jiri Svoboda
     2# Copyright (c) 2023 Jiri Svoboda
    33# All rights reserved.
    44#
    … …  
    2727#
    2828
     29deps = [ 'corecfg' ]
    2930src = files('taskmon.c')

  • uspace/srv/taskmon/taskmon.c

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    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

    r42c2e65 rdc5c303  
    11/*
    2  * Copyright (c) 2018 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4848#include <mem.h>
    4949#include <stdio.h>
     50#include <stdlib.h>
    5051#include <task.h>
    5152
    … …  
    5354
    5455static service_id_t svc_id;
     56
     57enum {
     58        max_rw_buf_size = 16384,
     59};
    5560
    5661/** Object in read-only memory area that will be shared.
    … …  
    6772 */
    6873static char rw_data[] = "Hello, world!";
     74
     75/** Buffer for reading/writing via read/write messages.
     76 *
     77 * It is allocated / size is set by IPC_TEST_SET_RW_BUF_SIZE
     78 */
     79static void *rw_buf;
     80/** Read/write buffer size */
     81size_t rw_buf_size;
    6982
    7083static void ipc_test_get_ro_area_size_srv(ipc_call_t *icall)
    … …  
    182195}
    183196
     197static void ipc_test_set_rw_buf_size_srv(ipc_call_t *icall)
     198{
     199        size_t size;
     200        void *nbuf;
     201
     202        log_msg(LOG_DEFAULT, LVL_DEBUG, "ipc_test_set_rw_buf_size_srv");
     203
     204        size = ipc_get_arg1(icall);
     205
     206        if (size == 0) {
     207                async_answer_0(icall, ERANGE);
     208                log_msg(LOG_DEFAULT, LVL_ERROR,
     209                    "Requested read/write buffer size is zero.");
     210                return;
     211        }
     212
     213        if (size > max_rw_buf_size) {
     214                async_answer_0(icall, ERANGE);
     215                log_msg(LOG_DEFAULT, LVL_ERROR, "Requested read/write buffer "
     216                    "size > %u", max_rw_buf_size);
     217                return;
     218        }
     219
     220        nbuf = realloc(rw_buf, size);
     221        if (nbuf == NULL) {
     222                async_answer_0(icall, ENOMEM);
     223                log_msg(LOG_DEFAULT, LVL_ERROR, "Out of memory.");
     224                return;
     225        }
     226
     227        rw_buf = nbuf;
     228        rw_buf_size = size;
     229        async_answer_0(icall, EOK);
     230}
     231
     232static void ipc_test_read_srv(ipc_call_t *icall)
     233{
     234        ipc_call_t call;
     235        errno_t rc;
     236        size_t size;
     237
     238        log_msg(LOG_DEFAULT, LVL_DEBUG, "ipc_test_read_srv");
     239
     240        if (!async_data_read_receive(&call, &size)) {
     241                async_answer_0(icall, EREFUSED);
     242                log_msg(LOG_DEFAULT, LVL_ERROR, "data_read_receive failed");
     243                return;
     244        }
     245
     246        if (size > rw_buf_size) {
     247                async_answer_0(&call, EINVAL);
     248                async_answer_0(icall, EINVAL);
     249                log_msg(LOG_DEFAULT, LVL_ERROR, "Invalid read size.");
     250                return;
     251        }
     252
     253        rc = async_data_read_finalize(&call, rw_buf, size);
     254        if (rc != EOK) {
     255                log_msg(LOG_DEFAULT, LVL_ERROR,
     256                    "data_read_finalize failed");
     257                async_answer_0(icall, EINVAL);
     258                return;
     259        }
     260
     261        async_answer_0(icall, EOK);
     262}
     263
     264static void ipc_test_write_srv(ipc_call_t *icall)
     265{
     266        ipc_call_t call;
     267        errno_t rc;
     268        size_t size;
     269
     270        log_msg(LOG_DEFAULT, LVL_DEBUG, "ipc_test_write_srv");
     271
     272        if (!async_data_write_receive(&call, &size)) {
     273                async_answer_0(icall, EREFUSED);
     274                log_msg(LOG_DEFAULT, LVL_ERROR, "data_write_receive failed");
     275                return;
     276        }
     277
     278        if (size > rw_buf_size) {
     279                async_answer_0(&call, EINVAL);
     280                async_answer_0(icall, EINVAL);
     281                log_msg(LOG_DEFAULT, LVL_ERROR, "Invalid write size.");
     282                return;
     283        }
     284
     285        rc = async_data_write_finalize(&call, rw_buf, size);
     286        if (rc != EOK) {
     287                log_msg(LOG_DEFAULT, LVL_ERROR,
     288                    "data_write_finalize failed");
     289                async_answer_0(icall, EINVAL);
     290                return;
     291        }
     292
     293        async_answer_0(icall, EOK);
     294}
     295
    184296static void ipc_test_connection(ipc_call_t *icall, void *arg)
    185297{
    … …  
    212324                        ipc_test_share_in_rw_srv(&call);
    213325                        break;
     326                case IPC_TEST_SET_RW_BUF_SIZE:
     327                        ipc_test_set_rw_buf_size_srv(&call);
     328                        break;
     329                case IPC_TEST_READ:
     330                        ipc_test_read_srv(&call);
     331                        break;
     332                case IPC_TEST_WRITE:
     333                        ipc_test_write_srv(&call);
     334                        break;
    214335                default:
    215336                        async_answer_0(&call, ENOTSUP);
    … …  
    222343{
    223344        errno_t rc;
     345        loc_srv_t *srv;
    224346
    225347        printf("%s: IPC test service\n", NAME);
    … …  
    232354        }
    233355
    234         rc = loc_server_register(NAME);
     356        rc = loc_server_register(NAME, &srv);
    235357        if (rc != EOK) {
    236358                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server. (%s)\n",
    … …  
    239361        }
    240362
    241         rc = loc_service_register(SERVICE_NAME_IPC_TEST, &svc_id);
    242         if (rc != EOK) {
     363        rc = loc_service_register(srv, SERVICE_NAME_IPC_TEST, &svc_id);
     364        if (rc != EOK) {
     365                loc_server_unregister(srv);
    243366                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service. (%s)\n",
    244367                    str_error(rc));

  • uspace/srv/test/ipc-test/meson.build

    r42c2e65 rdc5c303  
    11#
    2 # Copyright (c) 2018 Jiri Svoboda
     2# Copyright (c) 2023 Jiri Svoboda
    33# All rights reserved.
    44#
    … …  
    2727#
    2828
     29deps = [ 'ipctest' ]
    2930src = files('main.c')

  • uspace/srv/volsrv/volsrv.c

    r42c2e65 rdc5c303  
    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.