Changeset 241f1985 in mainline for uspace/lib


Ignore:
Timestamp:
2019-08-31T10:45:17Z (6 years ago)
Author:
Matthieu Riolo <matthieu.riolo@…>
Children:
102f641
Parents:
f92b315
git-author:
Matthieu Riolo <matthieu.riolo@…> (2019-08-23 22:04:34)
git-committer:
Matthieu Riolo <matthieu.riolo@…> (2019-08-31 10:45:17)
Message:

Correcting failure from previous merge

The commits from Michal Koutný from the branch system-daemon
where built on a old version of Helenos. Because of this
many types and API functions have changed. This commit
upgrades the merge code

Location:
uspace/lib
Files:
19 edited

Legend:

Unmodified
Added
Removed

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

    rf92b315 r241f1985  
    9999#include <async.h>
    100100#include "../private/async.h"
    101 #include "../private/ns.h"
    102101#undef _LIBC_ASYNC_C_
    103102
    … …  
    114113#include <stdbool.h>
    115114#include <stdlib.h>
     115#include <stdatomic.h>
    116116#include <mem.h>
    117 #include <stdlib.h>
    118117#include <macros.h>
    119118#include <as.h>
    … …  
    174173    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
    175174{
    176         async_sess_t *session = (async_sess_t *) malloc(sizeof(async_sess_t));
     175        async_sess_t *session = (async_sess_t *) calloc(1, sizeof(async_sess_t));
    177176
    178177        if (session != NULL) {
    179                 session->iface = 0;
    180178                session->mgmt = mgmt;
    181179                session->phone = phone;
    … …  
    189187                list_initialize(&session->exch_list);
    190188                fibril_mutex_initialize(&session->mutex);
    191                 atomic_set(&session->refcnt, 0);
    192                 &session.exchanges = 0;
    193189        } else {
    194190                errno = ENOMEM;
    … …  
    198194}
    199195
    200 int async_session_phone(async_sess_t *sess)
     196cap_phone_handle_t async_session_phone(async_sess_t *sess)
    201197{
    202198        return sess->phone;
    … …  
    859855        }
    860856
    861         async_sess_t *sess = create_session(phone, mgmt, iface, arg2, arg3);
     857        async_sess_t *sess = create_session(phone, iface & IFACE_EXCHANGE_MASK, iface, arg2, arg3);
    862858        if (sess == NULL) {
    863859                ipc_hangup(phone);
    864860        }
     861        sess->iface = iface;
    865862
    866863        return sess;
    … …  
    912909        if (rc != EOK) {
    913910                errno = rc;
    914                 free(sess);
    915911                return NULL;
    916912        }
    917913
    918         async_sess_t *sess = create_session(phone, mgmt, iface, arg2, arg3);
     914        async_sess_t *sess = create_session(phone, iface & IFACE_EXCHANGE_MASK, iface, arg2, arg3);
    919915        if (sess == NULL) {
    920916                ipc_hangup(phone);
    921917        }
     918        sess->iface = iface;
    922919
    923920        return sess;

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

    rf92b315 r241f1985  
    216216}
    217217
    218 static async_client_conn_t implicit_connection = NULL;
     218static async_port_handler_t implicit_connection = NULL;
     219
     220/** Setter for implicit_connection function pointer.
     221 *
     222 * @param conn Function that will implement a new connection fibril for
     223 *             unrouted calls.
     224 *
     225 */
     226void async_set_implicit_connection(async_port_handler_t conn)
     227{
     228        assert(implicit_connection == NULL);
     229        implicit_connection = conn;
     230}
     231
     232
    219233static fibril_rmutex_t client_mutex;
    220234static hash_table_t client_hash_table;
    … …  
    969983                return;
    970984        } else if (implicit_connection != NULL) {
    971                 async_new_connection(call->in_task_id, call->in_phone_hash,
    972                     callid, call, implicit_connection, NULL);
     985                connection_t *conn = calloc(1, sizeof(connection_t));
     986                if (!conn) {
     987                        ipc_answer_0(call->cap_handle, ENOMEM);
     988                        return;
     989                }
     990
     991                async_new_connection(conn, call->task_id, call, implicit_connection, NULL);
    973992                return;
    974993        }
    … …  
    17491768        async_sess_t *sess = create_session(phandle, mgmt, 0, 0, 0);
    17501769        if (sess == NULL) {
    1751                 ipc_hangup(phone);
     1770                ipc_hangup(phandle);
    17521771                async_answer_0(&call, errno);
    17531772        } else {

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

    rf92b315 r241f1985  
    5959}
    6060
    61 /*
    62  * XXX ns does not know about session_primary, so we create an extra session for
    63  * actual communicaton
    64  */
    65 static async_sess_t *sess_primary = NULL;
    66 
    6761errno_t service_register(service_t service, iface_t iface,
    6862    async_port_handler_t handler, void *data)
    … …  
    9690        async_set_fallback_port_handler(handler, data);
    9791
    98         async_sess_t *sess = get_session_primary();
    99         if (sess == NULL)
    100                 return EIO;
    101 
    102         async_exch_t *exch = async_exchange_begin(sess);
     92        async_exch_t *exch = ns_exchange_begin();
    10393
    10494        ipc_call_t answer;
    … …  
    10696        errno_t rc = async_connect_to_me(exch, INTERFACE_ANY, service, 0);
    10797
    108         async_exchange_end(exch);
     98        ns_exchange_end(exch);
    10999
    110100        if (rc != EOK) {
    … …  
    138128        async_sess_args_set(sess, iface, arg3, 0);
    139129
    140         return csess;
     130        return sess;
    141131}
    142132
    … …  
    164154errno_t ns_ping(void)
    165155{
    166         async_exch_t *exch = ns_exchange_begin(sess);
     156        async_exch_t *exch = ns_exchange_begin();
    167157        errno_t rc = async_req_0_0(exch, NS_PING);
    168158        ns_exchange_end(exch);

  • uspace/lib/c/generic/private/async.h

    rf92b315 r241f1985  
    4242#include <time.h>
    4343#include <stdbool.h>
     44#include <stdatomic.h>
    4445
    4546/** Session data */
    … …  
    106107
    107108extern void async_reply_received(ipc_call_t *);
    108 extern async_sess_t *create_session(int, exch_mgmt_t,
     109extern async_sess_t *create_session(cap_phone_handle_t, exch_mgmt_t,
    109110        sysarg_t, sysarg_t, sysarg_t);
    110 extern int async_session_phone(async_sess_t *);
     111extern cap_phone_handle_t async_session_phone(async_sess_t *);
    111112
    112113#endif

  • uspace/lib/c/generic/private/taskman.h

    rf92b315 r241f1985  
    3636#define LIBC_PRIVATE_TASKMAN_H_
    3737
    38 #include <async.h>
     38#include "async.h"
    3939
    4040extern async_sess_t *session_taskman;

  • uspace/lib/c/generic/task.c

    rf92b315 r241f1985  
    385385        if (rc == EOK || rc == EINTR) {
    386386                if (wait->flags & TASK_WAIT_EXIT && texit)
    387                         *texit = ipc_get_arg1(wait->result);
     387                        *texit = ipc_get_arg1(&wait->result);
    388388                if (wait->flags & TASK_WAIT_RETVAL && retval)
    389                         *retval = ipc_get_arg2(wait->result);
     389                        *retval = ipc_get_arg2(&wait->result);
    390390               
    391391        }
    … …  
    394394                /* Is there another wait to be done? Wait for it! */
    395395                int old_flags = wait->flags;
    396                 wait->flags = ipc_get_arg3(wait->result);
     396                wait->flags = ipc_get_arg3(&wait->result);
    397397                if (wait->flags != 0 && (old_flags & TASK_WAIT_BOTH)) {
    398398                        rc = task_setup_wait(wait->tid, wait);
    … …  
    438438                return EIO;
    439439
    440         errno_t rc = (int) async_req_2_0(exch, TASKMAN_RETVAL, val, wait_for_exit);
     440        errno_t rc = async_req_2_0(exch, TASKMAN_RETVAL, val, wait_for_exit);
    441441        taskman_exchange_end(exch);
    442442       

  • uspace/lib/c/generic/task_event.c

    rf92b315 r241f1985  
    3737#include <macros.h>
    3838#include <task.h>
     39#include <assert.h>
    3940
    4041#include "private/taskman.h"
    … …  
    4243static task_event_handler_t task_event_handler = NULL;
    4344
    44 static void taskman_task_event(ipc_callid_t iid, ipc_call_t *icall)
     45static void taskman_task_event(ipc_call_t *icall)
    4546{
    4647        task_id_t tid = (task_id_t)
    47             MERGE_LOUP32(IPC_GET_ARG1(*icall), IPC_GET_ARG2(*icall));
    48         int flags = IPC_GET_ARG3(*icall);
    49         task_exit_t texit = IPC_GET_ARG4(*icall);
    50         int retval = IPC_GET_ARG5(*icall);
     48            MERGE_LOUP32(ipc_get_arg1(icall), ipc_get_arg2(icall));
     49        int flags = ipc_get_arg3(icall);
     50        task_exit_t texit = ipc_get_arg4(icall);
     51        int retval = ipc_get_arg5(icall);
    5152
    5253        task_event_handler(tid, flags, texit, retval);
    5354
    54         async_answer_0(iid, EOK);
     55        async_answer_0(icall, EOK);
    5556}
    5657
    57 static void taskman_event_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     58static void taskman_event_conn(ipc_call_t *icall, void *arg)
    5859{
    5960        /* Accept connection */
    60         async_answer_0(iid, EOK);
     61        async_answer_0(icall, EOK);
    6162
    6263        while (true) {
    6364                ipc_call_t call;
    64                 ipc_callid_t callid = async_get_call(&call);
    65 
    66                 if (!IPC_GET_IMETHOD(call)) {
     65               
     66                if (!async_get_call(&call) || !ipc_get_imethod(&call)) {
    6767                        /* Hangup, end of game */
    6868                        break;
    6969                }
    7070
    71                 switch (IPC_GET_IMETHOD(call)) {
     71                switch (ipc_get_imethod(&call)) {
    7272                case TASKMAN_EV_TASK:
    73                         taskman_task_event(callid, &call);
     73                        taskman_task_event(&call);
    7474                        break;
    7575                default:
    76                         async_answer_0(callid, ENOTSUP);
     76                        async_answer_0(&call, ENOTSUP);
    7777                        break;
    7878                }
    … …  
    8383 * Blocks, calls handler in another fibril
    8484 */
    85 int task_register_event_handler(task_event_handler_t handler, bool past_events)
     85errno_t task_register_event_handler(task_event_handler_t handler, bool past_events)
    8686{
    8787        /*
    … …  
    9797        aid_t req = async_send_1(exch, TASKMAN_EVENT_CALLBACK, past_events, NULL);
    9898
    99         int rc = async_connect_to_me(exch, 0, 0, 0, taskman_event_conn, NULL);
     99        port_id_t port;
     100        errno_t rc = async_create_callback_port(exch, INTERFACE_TASKMAN_CB, 0, 0,
     101                taskman_event_conn, NULL, &port);
    100102        taskman_exchange_end(exch);
    101103
    … …  
    104106        }
    105107
    106         sysarg_t retval;
     108        errno_t retval;
    107109        async_wait_for(req, &retval);
    108110        return retval;

  • uspace/lib/c/generic/taskman.c

    rf92b315 r241f1985  
    103103        assert(exch);
    104104
    105         async_sess_t *sess = async_connect_me_to(EXCHANGE_ATOMIC,
    106             exch, TASKMAN_CONNECT_TO_NS, 0, 0);
     105        async_sess_t *sess = async_connect_me_to(exch, INTERFACE_NS,
     106                TASKMAN_CONNECT_TO_NS, 0);
    107107        async_exchange_end(exch);
    108108
    … …  
    116116
    117117        async_exch_t *exch = async_exchange_begin(session_taskman);
    118         async_sess_t *sess = async_connect_me_to(EXCHANGE_SERIALIZE,
    119             exch, TASKMAN_CONNECT_TO_LOADER, 0, 0);
     118        async_sess_t *sess = async_connect_me_to(exch, INTERFACE_LOADER,
     119            TASKMAN_CONNECT_TO_LOADER, 0);
    120120        async_exchange_end(exch);
    121121
    … …  
    136136 * @return EOK on success, otherwise propagated error code
    137137 */
    138 int taskman_intro_loader(void)
     138errno_t taskman_intro_loader(void)
    139139{
    140140        assert(session_taskman);
    141141
    142142        async_exch_t *exch = async_exchange_begin(session_taskman);
    143         int rc = async_connect_to_me(
    144             exch, TASKMAN_LOADER_CALLBACK, 0, 0, NULL, NULL);
     143        errno_t rc = async_connect_to_me(exch, INTERFACE_LOADER, TASKMAN_LOADER_CALLBACK, 0);
    145144        async_exchange_end(exch);
    146145
    … …  
    152151 * @return EOK on success, otherwise propagated error code
    153152 */
    154 int taskman_intro_ns(void)
     153errno_t taskman_intro_ns(void)
    155154{
    156155        assert(session_taskman);
    … …  
    159158        aid_t req = async_send_0(exch, TASKMAN_I_AM_NS, NULL);
    160159
    161         int rc = async_connect_to_me(exch, 0, 0, 0, NULL, NULL);
     160        errno_t rc = async_connect_to_me(exch, INTERFACE_NS, 0, 0);
    162161        taskman_exchange_end(exch);
    163162
    … …  
    166165        }
    167166
    168         sysarg_t retval;
     167        errno_t retval;
    169168        async_wait_for(req, &retval);
    170169        return retval;

  • uspace/lib/c/generic/taskman_noasync.c

    rf92b315 r241f1985  
    3333 */
    3434
    35 #define LIBC_ASYNC_C_
    36 #include <ipc/ipc.h>
    3735#include "private/async.h"
    3836#include "private/taskman.h"
    39 #undef LIBC_ASYNC_C_
     37
     38#undef _LIBC_ASYNC_H_
     39#include <ipc/ipc.h>
     40#define _LIBC_ASYNC_H_
    4041
    4142#include <errno.h>
    … …  
    5051 * @return EOK on success, otherwise propagated error code
    5152 */
    52 int taskman_intro_ns_noasync(void)
     53errno_t taskman_intro_ns_noasync(void)
    5354{
    5455        assert(session_taskman);
    55         int phone = async_session_phone(session_taskman);
     56        cap_phone_handle_t phone = async_session_phone(session_taskman);
    5657
    57         ipc_call_async_0(phone, TASKMAN_I_AM_NS, NULL, NULL, false);
     58        ipc_call_async_0(phone, TASKMAN_I_AM_NS, NULL);
    5859
    59         ipc_call_async_3(phone, IPC_M_CONNECT_TO_ME, 0, 0, 0, NULL, NULL, false);
     60        ipc_call_async_3(phone, IPC_M_CONNECT_TO_ME, 0, 0, 0, NULL);
    6061
    6162        /*
    … …  
    6768
    6869
    69 void task_retval_noasync(int retval)
     70void task_retval_noasync(errno_t retval)
    7071{
    7172        assert(session_taskman);
    72         int phone = async_session_phone(session_taskman);
     73        cap_phone_handle_t phone = async_session_phone(session_taskman);
    7374
    7475        /* Just send it and don't wait for an answer. */
    75         ipc_call_async_2(phone, TASKMAN_RETVAL, retval, false,
    76             NULL, NULL, false);
     76        ipc_call_async_2(phone, TASKMAN_RETVAL, retval, false, NULL);
    7777}
    7878

  • uspace/lib/c/include/adt/dyn_array.h

    rf92b315 r241f1985  
    4141typedef struct {
    4242        /** Data buffer of array */
    43         uint8_t *_data;
     43        void *_data;
    4444        /** Size on bytes of a single item */
    4545        size_t _item_size;

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

    rf92b315 r241f1985  
    132132extern void async_put_client_data_by_id(task_id_t);
    133133
    134 extern void async_set_implicit_connection(async_client_conn_t);
     134extern void async_set_implicit_connection(async_port_handler_t);
    135135
    136136extern errno_t async_create_port(iface_t, async_port_handler_t, void *,

  • uspace/lib/c/include/ipc/services.h

    rf92b315 r241f1985  
    5555#define SERVICE_NAME_CLIPBOARD "clipboard"
    5656#define SERVICE_NAME_CORECFG  "corecfg"
     57#define SERVICE_NAME_DEVMAN   "devman"
    5758#define SERVICE_NAME_DHCP     "net/dhcp"
    5859#define SERVICE_NAME_DNSR     "net/dnsr"

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

    rf92b315 r241f1985  
    7676
    7777/* Implemented in task_event.c */
    78 extern int task_register_event_handler(task_event_handler_t, bool);
     78extern errno_t task_register_event_handler(task_event_handler_t, bool);
    7979
    8080#endif

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

    rf92b315 r241f1985  
    4040/* Internal functions to be used by loader only */
    4141extern async_sess_t *taskman_get_session(void);
    42 extern int taskman_intro_loader(void);
     42extern errno_t taskman_intro_loader(void);
    4343
    4444/* Internal functions to be used by NS only */
    45 extern int taskman_intro_ns(void);
     45extern errno_t taskman_intro_ns(void);
    4646
    4747#endif

  • uspace/lib/conf/src/configuration.c

    rf92b315 r241f1985  
    138138{
    139139        bool value;
    140         if (stricmp(string, "true") == 0 ||
    141             stricmp(string, "yes") == 0 ||
    142             stricmp(string, "1") == 0) {
     140        if (str_casecmp(string, "true") == 0 ||
     141            str_casecmp(string, "yes") == 0 ||
     142            str_casecmp(string, "1") == 0) {
    143143                value = true;
    144         } else if (stricmp(string, "false") == 0 ||
    145             stricmp(string, "no") == 0 ||
    146             stricmp(string, "0") == 0) {
     144        } else if (str_casecmp(string, "false") == 0 ||
     145            str_casecmp(string, "no") == 0 ||
     146            str_casecmp(string, "0") == 0) {
    147147                value = false;
    148148        } else {

  • uspace/lib/conf/src/ini.c

    rf92b315 r241f1985  
    7575}
    7676
    77 static size_t ini_section_ht_key_hash(void *key)
     77static size_t ini_section_ht_key_hash(const void *key)
    7878{
    7979        /* Nameless default section */
    … …  
    9191}
    9292
    93 static bool ini_section_ht_key_equal(void *key, const ht_link_t *item)
     93static bool ini_section_ht_key_equal(const void *key, const ht_link_t *item)
    9494{
    9595        const char *name = key;
    … …  
    119119}
    120120
    121 static size_t ini_item_ht_key_hash(void *key)
     121static size_t ini_item_ht_key_hash(const void *key)
    122122{
    123123        return hash_string((const char *)key);
    … …  
    131131}
    132132
    133 static bool ini_item_ht_key_equal(void *key, const ht_link_t *item)
     133static bool ini_item_ht_key_equal(const void *key, const ht_link_t *item)
    134134{
    135135        return str_cmp((const char *)key,
    … …  
    501501{
    502502        iterator->cur_item =
    503             hash_table_find_next(iterator->table, iterator->cur_item);
     503            hash_table_find_next(iterator->table, iterator->first_item, iterator->cur_item);
    504504        iterator->incremented = true;
    505505}

  • uspace/lib/sysman/include/sysman/ctl.h

    rf92b315 r241f1985  
    3333#include <sysman/unit.h>
    3434
    35 int sysman_unit_handle(const char *, unit_handle_t *);
     35errno_t sysman_unit_handle(const char *, unit_handle_t *);
    3636
    37 int sysman_unit_start_by_name(const char *, int);
    38 int sysman_unit_start(unit_handle_t, int);
    39 int sysman_unit_stop(unit_handle_t, int);
     37errno_t sysman_unit_start_by_name(const char *, int);
     38errno_t sysman_unit_start(unit_handle_t, int);
     39errno_t sysman_unit_stop(unit_handle_t, int);
    4040
    41 int sysman_get_units(unit_handle_t **, size_t *);
     41errno_t sysman_get_units(unit_handle_t **, size_t *);
    4242
    43 int sysman_unit_get_name(unit_handle_t, char *, size_t);
    44 int sysman_unit_get_state(unit_handle_t, unit_state_t *);
     43errno_t sysman_unit_get_name(unit_handle_t, char *, size_t);
     44errno_t sysman_unit_get_state(unit_handle_t, unit_state_t *);
    4545
    46 int sysman_shutdown(void);
     46errno_t sysman_shutdown(void);
    4747#endif

  • uspace/lib/sysman/src/ctl.c

    rf92b315 r241f1985  
    3434#include <sysman/sysman.h>
    3535
    36 int sysman_unit_handle(const char *unit_name, unit_handle_t *handle_ptr)
     36errno_t sysman_unit_handle(const char *unit_name, unit_handle_t *handle_ptr)
    3737{
    3838        async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
    … …  
    4040        ipc_call_t call;
    4141        aid_t req = async_send_0(exch, SYSMAN_CTL_UNIT_HANDLE, &call);
    42         sysarg_t rc = async_data_write_start(exch, unit_name, str_size(unit_name));
     42        errno_t rc = async_data_write_start(exch, unit_name, str_size(unit_name));
    4343        sysman_exchange_end(exch);
    4444
    … …  
    5050        async_wait_for(req, &rc);
    5151        if (rc == EOK) {
    52                 *handle_ptr = IPC_GET_ARG1(call);
     52                *handle_ptr = ipc_get_arg1(&call);
    5353        }
    5454        return rc;
    … …  
    6464 * TODO convert to name->handle API
    6565 */
    66 int sysman_unit_start_by_name(const char *unit_name, int flags)
     66errno_t sysman_unit_start_by_name(const char *unit_name, int flags)
    6767{
    6868        async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
    6969
    7070        aid_t req = async_send_1(exch, SYSMAN_CTL_UNIT_START_BY_NAME, flags, NULL);
    71         sysarg_t rc = async_data_write_start(exch, unit_name, str_size(unit_name));
     71        errno_t rc = async_data_write_start(exch, unit_name, str_size(unit_name));
    7272        sysman_exchange_end(exch);
    7373
    … …  
    8181}
    8282
    83 int sysman_unit_start(unit_handle_t handle, int flags)
    84 {
    85         async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
    86 
    87         int rc = async_req_2_0(exch, SYSMAN_CTL_UNIT_START, handle, flags);
     83errno_t sysman_unit_start(unit_handle_t handle, int flags)
     84{
     85        async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
     86
     87        errno_t rc = async_req_2_0(exch, SYSMAN_CTL_UNIT_START, handle, flags);
    8888        sysman_exchange_end(exch);
    8989       
    … …  
    9191}
    9292
    93 int sysman_unit_stop(unit_handle_t handle, int flags)
    94 {
    95         async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
    96 
    97         int rc = async_req_2_0(exch, SYSMAN_CTL_UNIT_STOP, handle, flags);
     93errno_t sysman_unit_stop(unit_handle_t handle, int flags)
     94{
     95        async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
     96
     97        errno_t rc = async_req_2_0(exch, SYSMAN_CTL_UNIT_STOP, handle, flags);
    9898        sysman_exchange_end(exch);
    9999       
    … …  
    101101}
    102102
    103 static int sysman_get_units_once(sysarg_t *buf, size_t buf_size,
     103static errno_t sysman_get_units_once(sysarg_t *buf, size_t buf_size,
    104104    size_t *act_size)
    105105{
    … …  
    108108        ipc_call_t answer;
    109109        aid_t req = async_send_0(exch, SYSMAN_CTL_GET_UNITS, &answer);
    110         int rc = async_data_read_start(exch, buf, buf_size);
    111 
    112         sysman_exchange_end(exch);
    113 
    114         if (rc != EOK) {
    115                 async_forget(req);
    116                 return rc;
    117         }
    118 
    119         sysarg_t retval;
     110        errno_t rc = async_data_read_start(exch, buf, buf_size);
     111
     112        sysman_exchange_end(exch);
     113
     114        if (rc != EOK) {
     115                async_forget(req);
     116                return rc;
     117        }
     118
     119        errno_t retval;
    120120        async_wait_for(req, &retval);
    121121
    … …  
    124124        }
    125125
    126         *act_size = IPC_GET_ARG1(answer);
     126        *act_size = ipc_get_arg1(&answer);
    127127        return EOK;
    128128}
    129129
    130 int sysman_get_units(unit_handle_t **units_ptr, size_t *cnt_ptr)
     130errno_t sysman_get_units(unit_handle_t **units_ptr, size_t *cnt_ptr)
    131131{
    132132        *units_ptr = NULL;
    … …  
    138138
    139139        while (true) {
    140                 int rc = sysman_get_units_once(units, alloc_size, &act_size);
     140                errno_t rc = sysman_get_units_once(units, alloc_size, &act_size);
    141141                if (rc != EOK) {
    142142                        return rc;
    … …  
    159159}
    160160
    161 int sysman_unit_get_name(unit_handle_t handle, char *buf, size_t buf_size)
     161errno_t sysman_unit_get_name(unit_handle_t handle, char *buf, size_t buf_size)
    162162{
    163163        async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
    … …  
    165165        ipc_call_t answer;
    166166        aid_t req = async_send_1(exch, SYSMAN_CTL_UNIT_GET_NAME, handle, &answer);
    167         int rc = async_data_read_start(exch, buf, buf_size);
    168 
    169         sysman_exchange_end(exch);
    170 
    171         if (rc != EOK) {
    172                 async_forget(req);
    173                 return rc;
    174         }
    175 
    176         sysarg_t retval;
     167        errno_t rc = async_data_read_start(exch, buf, buf_size);
     168
     169        sysman_exchange_end(exch);
     170
     171        if (rc != EOK) {
     172                async_forget(req);
     173                return rc;
     174        }
     175
     176        errno_t retval;
    177177        async_wait_for(req, &retval);
    178178
    … …  
    184184}
    185185
    186 int sysman_unit_get_state(unit_handle_t handle, unit_state_t *state)
    187 {
    188         async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
    189         int rc = async_req_1_1(exch, SYSMAN_CTL_UNIT_GET_STATE, handle, state);
    190         sysman_exchange_end(exch);
    191 
    192         return rc;
    193 }
    194 
    195 int sysman_shutdown(void)
    196 {
    197         async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
    198         int rc = async_req_0_0(exch, SYSMAN_CTL_SHUTDOWN);
    199         sysman_exchange_end(exch);
    200 
    201         return rc;
    202 }
     186errno_t sysman_unit_get_state(unit_handle_t handle, unit_state_t *state)
     187{
     188        async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
     189        errno_t rc = async_req_1_1(exch, SYSMAN_CTL_UNIT_GET_STATE, handle, (sysarg_t *)state);
     190        sysman_exchange_end(exch);
     191
     192        return rc;
     193}
     194
     195errno_t sysman_shutdown(void)
     196{
     197        async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
     198        errno_t rc = async_req_0_0(exch, SYSMAN_CTL_SHUTDOWN);
     199        sysman_exchange_end(exch);
     200
     201        return rc;
     202}

  • uspace/lib/sysman/src/sysman.c

    rf92b315 r241f1985  
    3737        if (sysman_sess[iface] == NULL) {
    3838                // TODO serialize vs parallel
    39                 sysman_sess[iface] = service_connect_blocking(EXCHANGE_SERIALIZE,
    40                     SERVICE_SYSMAN, iface, 0);
     39                sysman_sess[iface] = service_connect_blocking(SERVICE_SYSMAN, INTERFACE_SYSMAN, iface);
    4140        }
    4241
Note: See TracChangeset for help on using the changeset viewer.