Index: abi/include/abi/ipc/interfaces.h =================================================================== --- abi/include/abi/ipc/interfaces.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ abi/include/abi/ipc/interfaces.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -187,5 +187,11 @@ FOURCC_COMPACT('i', 'p', 'c', 't') | IFACE_EXCHANGE_SERIALIZE, INTERFACE_PCI = - FOURCC_COMPACT('p', 'c', 'i', ' ') | IFACE_EXCHANGE_SERIALIZE + FOURCC_COMPACT('p', 'c', 'i', ' ') | IFACE_EXCHANGE_SERIALIZE, + INTERFACE_TASKMAN_CB = + FOURCC_COMPACT('t', 'a', 's', 'k') | IFACE_EXCHANGE_SERIALIZE | IFACE_MOD_CALLBACK, + INTERFACE_NS = + FOURCC_COMPACT('n', 's', ' ', ' ') | IFACE_EXCHANGE_ATOMIC, + INTERFACE_SYSMAN = + FOURCC_COMPACT('s', 'y', 's', 'm') | IFACE_EXCHANGE_SERIALIZE } iface_t; Index: boot/Makefile =================================================================== --- boot/Makefile (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ boot/Makefile (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -127,5 +127,5 @@ find $(USPACE_PATH)/dist -mindepth 1 -maxdepth 1 -type f -exec rm \{\} \; rm -rf $(USPACE_PATH)/dist/app - rm -f $(USPACE_PATH)/dist/cfg/* + rm -rf $(USPACE_PATH)/dist/cfg/* rm -rf $(USPACE_PATH)/dist/srv rm -rf $(USPACE_PATH)/dist/drv/* Index: kernel/generic/src/proc/task.c =================================================================== --- kernel/generic/src/proc/task.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ kernel/generic/src/proc/task.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -134,5 +134,5 @@ printf("[%" PRIu64 "] ", task->taskid); #endif - task_kill_internal(task); + task_kill_internal(task, EXIT_REASON_KILLED); } Index: uspace/app/sbi/src/os/helenos.c =================================================================== --- uspace/app/sbi/src/os/helenos.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/app/sbi/src/os/helenos.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -251,7 +251,5 @@ task_id_t tid; task_wait_t twait; - task_exit_t texit; errno_t rc; - int retval; task_wait_set(&twait, TASK_WAIT_EXIT); Index: uspace/app/sysctl/Makefile =================================================================== --- uspace/app/sysctl/Makefile (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/app/sysctl/Makefile (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -28,5 +28,5 @@ USPACE_PREFIX = ../.. -LIBS = $(LIBSYSMAN_PREFIX)/libsysman.a +LIBS = sysman EXTRA_CFLAGS += -I$(LIBSYSMAN_PREFIX)/include BINARY = sysctl Index: uspace/app/sysctl/main.c =================================================================== --- uspace/app/sysctl/main.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/app/sysctl/main.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -39,5 +39,6 @@ #include #include -#include +#include + #define NAME "sysctl" @@ -66,10 +67,10 @@ } -static int list_units(int argc, char *argv[]) +static errno_t list_units(int argc, char *argv[]) { unit_handle_t *units; size_t unit_cnt; - int rc = sysman_get_units(&units, &unit_cnt); + errno_t rc = sysman_get_units(&units, &unit_cnt); if (rc != EOK) { return rc; @@ -98,10 +99,10 @@ } -static int start(int argc, char *argv[]) +static errno_t start(int argc, char *argv[]) { unit_handle_t handle; char *unit_name = argv[1]; - int rc = sysman_unit_handle(unit_name, &handle); + errno_t rc = sysman_unit_handle(unit_name, &handle); if (rc != EOK) { printf("Cannot obtain handle for unit '%s' (%s).\n", @@ -120,10 +121,10 @@ } -static int stop(int argc, char *argv[]) +static errno_t stop(int argc, char *argv[]) { unit_handle_t handle; char *unit_name = argv[1]; - int rc = sysman_unit_handle(unit_name, &handle); + errno_t rc = sysman_unit_handle(unit_name, &handle); if (rc != EOK) { printf("Cannot obtain handle for unit '%s' (%s).\n", @@ -142,12 +143,12 @@ } -static int shutdown(int argc, char *argv[]) +static errno_t shutdown(int argc, char *argv[]) { const int delay = 3; printf("Will shutdown in %i seconds...\n", delay); - sleep(delay); + fibril_sleep(delay); printf("Shutdown now.\n"); - int rc = sysman_shutdown(); + errno_t rc = sysman_shutdown(); if (rc != EOK) { printf("Shutdown request failed: %s.\n", str_error(rc)); Index: uspace/app/tester/proc/dummy_task.c =================================================================== --- uspace/app/tester/proc/dummy_task.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/app/tester/proc/dummy_task.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -27,4 +27,5 @@ */ +#include #include #include Index: uspace/lib/c/generic/async/client.c =================================================================== --- uspace/lib/c/generic/async/client.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/generic/async/client.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -99,5 +99,4 @@ #include #include "../private/async.h" -#include "../private/ns.h" #undef _LIBC_ASYNC_C_ @@ -114,6 +113,6 @@ #include #include +#include #include -#include #include #include @@ -174,8 +173,7 @@ sysarg_t arg1, sysarg_t arg2, sysarg_t arg3) { - async_sess_t *session = (async_sess_t *) malloc(sizeof(async_sess_t)); + async_sess_t *session = (async_sess_t *) calloc(1, sizeof(async_sess_t)); if (session != NULL) { - session->iface = 0; session->mgmt = mgmt; session->phone = phone; @@ -189,6 +187,4 @@ list_initialize(&session->exch_list); fibril_mutex_initialize(&session->mutex); - atomic_set(&session->refcnt, 0); - &session.exchanges = 0; } else { errno = ENOMEM; @@ -198,5 +194,5 @@ } -int async_session_phone(async_sess_t *sess) +cap_phone_handle_t async_session_phone(async_sess_t *sess) { return sess->phone; @@ -859,8 +855,9 @@ } - async_sess_t *sess = create_session(phone, mgmt, iface, arg2, arg3); + async_sess_t *sess = create_session(phone, iface & IFACE_EXCHANGE_MASK, iface, arg2, arg3); if (sess == NULL) { ipc_hangup(phone); } + sess->iface = iface; return sess; @@ -912,12 +909,12 @@ if (rc != EOK) { errno = rc; - free(sess); return NULL; } - async_sess_t *sess = create_session(phone, mgmt, iface, arg2, arg3); + async_sess_t *sess = create_session(phone, iface & IFACE_EXCHANGE_MASK, iface, arg2, arg3); if (sess == NULL) { ipc_hangup(phone); } + sess->iface = iface; return sess; Index: uspace/lib/c/generic/async/server.c =================================================================== --- uspace/lib/c/generic/async/server.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/generic/async/server.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -216,5 +216,19 @@ } -static async_client_conn_t implicit_connection = NULL; +static async_port_handler_t implicit_connection = NULL; + +/** Setter for implicit_connection function pointer. + * + * @param conn Function that will implement a new connection fibril for + * unrouted calls. + * + */ +void async_set_implicit_connection(async_port_handler_t conn) +{ + assert(implicit_connection == NULL); + implicit_connection = conn; +} + + static fibril_rmutex_t client_mutex; static hash_table_t client_hash_table; @@ -969,6 +983,11 @@ return; } else if (implicit_connection != NULL) { - async_new_connection(call->in_task_id, call->in_phone_hash, - callid, call, implicit_connection, NULL); + connection_t *conn = calloc(1, sizeof(connection_t)); + if (!conn) { + ipc_answer_0(call->cap_handle, ENOMEM); + return; + } + + async_new_connection(conn, call->task_id, call, implicit_connection, NULL); return; } @@ -1749,5 +1768,5 @@ async_sess_t *sess = create_session(phandle, mgmt, 0, 0, 0); if (sess == NULL) { - ipc_hangup(phone); + ipc_hangup(phandle); async_answer_0(&call, errno); } else { Index: uspace/lib/c/generic/ns.c =================================================================== --- uspace/lib/c/generic/ns.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/generic/ns.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -59,10 +59,4 @@ } -/* - * XXX ns does not know about session_primary, so we create an extra session for - * actual communicaton - */ -static async_sess_t *sess_primary = NULL; - errno_t service_register(service_t service, iface_t iface, async_port_handler_t handler, void *data) @@ -96,9 +90,5 @@ async_set_fallback_port_handler(handler, data); - async_sess_t *sess = get_session_primary(); - if (sess == NULL) - return EIO; - - async_exch_t *exch = async_exchange_begin(sess); + async_exch_t *exch = ns_exchange_begin(); ipc_call_t answer; @@ -106,5 +96,5 @@ errno_t rc = async_connect_to_me(exch, INTERFACE_ANY, service, 0); - async_exchange_end(exch); + ns_exchange_end(exch); if (rc != EOK) { @@ -138,5 +128,5 @@ async_sess_args_set(sess, iface, arg3, 0); - return csess; + return sess; } @@ -164,5 +154,5 @@ errno_t ns_ping(void) { - async_exch_t *exch = ns_exchange_begin(sess); + async_exch_t *exch = ns_exchange_begin(); errno_t rc = async_req_0_0(exch, NS_PING); ns_exchange_end(exch); Index: uspace/lib/c/generic/private/async.h =================================================================== --- uspace/lib/c/generic/private/async.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/generic/private/async.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -42,4 +42,5 @@ #include #include +#include /** Session data */ @@ -106,7 +107,7 @@ extern void async_reply_received(ipc_call_t *); -extern async_sess_t *create_session(int, exch_mgmt_t, +extern async_sess_t *create_session(cap_phone_handle_t, exch_mgmt_t, sysarg_t, sysarg_t, sysarg_t); -extern int async_session_phone(async_sess_t *); +extern cap_phone_handle_t async_session_phone(async_sess_t *); #endif Index: uspace/lib/c/generic/private/taskman.h =================================================================== --- uspace/lib/c/generic/private/taskman.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/generic/private/taskman.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -36,5 +36,5 @@ #define LIBC_PRIVATE_TASKMAN_H_ -#include +#include "async.h" extern async_sess_t *session_taskman; Index: uspace/lib/c/generic/task.c =================================================================== --- uspace/lib/c/generic/task.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/generic/task.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -385,7 +385,7 @@ if (rc == EOK || rc == EINTR) { if (wait->flags & TASK_WAIT_EXIT && texit) - *texit = ipc_get_arg1(wait->result); + *texit = ipc_get_arg1(&wait->result); if (wait->flags & TASK_WAIT_RETVAL && retval) - *retval = ipc_get_arg2(wait->result); + *retval = ipc_get_arg2(&wait->result); } @@ -394,5 +394,5 @@ /* Is there another wait to be done? Wait for it! */ int old_flags = wait->flags; - wait->flags = ipc_get_arg3(wait->result); + wait->flags = ipc_get_arg3(&wait->result); if (wait->flags != 0 && (old_flags & TASK_WAIT_BOTH)) { rc = task_setup_wait(wait->tid, wait); @@ -438,5 +438,5 @@ return EIO; - errno_t rc = (int) async_req_2_0(exch, TASKMAN_RETVAL, val, wait_for_exit); + errno_t rc = async_req_2_0(exch, TASKMAN_RETVAL, val, wait_for_exit); taskman_exchange_end(exch); Index: uspace/lib/c/generic/task_event.c =================================================================== --- uspace/lib/c/generic/task_event.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/generic/task_event.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -37,4 +37,5 @@ #include #include +#include #include "private/taskman.h" @@ -42,37 +43,36 @@ static task_event_handler_t task_event_handler = NULL; -static void taskman_task_event(ipc_callid_t iid, ipc_call_t *icall) +static void taskman_task_event(ipc_call_t *icall) { task_id_t tid = (task_id_t) - MERGE_LOUP32(IPC_GET_ARG1(*icall), IPC_GET_ARG2(*icall)); - int flags = IPC_GET_ARG3(*icall); - task_exit_t texit = IPC_GET_ARG4(*icall); - int retval = IPC_GET_ARG5(*icall); + MERGE_LOUP32(ipc_get_arg1(icall), ipc_get_arg2(icall)); + int flags = ipc_get_arg3(icall); + task_exit_t texit = ipc_get_arg4(icall); + int retval = ipc_get_arg5(icall); task_event_handler(tid, flags, texit, retval); - async_answer_0(iid, EOK); + async_answer_0(icall, EOK); } -static void taskman_event_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg) +static void taskman_event_conn(ipc_call_t *icall, void *arg) { /* Accept connection */ - async_answer_0(iid, EOK); + async_answer_0(icall, EOK); while (true) { ipc_call_t call; - ipc_callid_t callid = async_get_call(&call); - - if (!IPC_GET_IMETHOD(call)) { + + if (!async_get_call(&call) || !ipc_get_imethod(&call)) { /* Hangup, end of game */ break; } - switch (IPC_GET_IMETHOD(call)) { + switch (ipc_get_imethod(&call)) { case TASKMAN_EV_TASK: - taskman_task_event(callid, &call); + taskman_task_event(&call); break; default: - async_answer_0(callid, ENOTSUP); + async_answer_0(&call, ENOTSUP); break; } @@ -83,5 +83,5 @@ * Blocks, calls handler in another fibril */ -int task_register_event_handler(task_event_handler_t handler, bool past_events) +errno_t task_register_event_handler(task_event_handler_t handler, bool past_events) { /* @@ -97,5 +97,7 @@ aid_t req = async_send_1(exch, TASKMAN_EVENT_CALLBACK, past_events, NULL); - int rc = async_connect_to_me(exch, 0, 0, 0, taskman_event_conn, NULL); + port_id_t port; + errno_t rc = async_create_callback_port(exch, INTERFACE_TASKMAN_CB, 0, 0, + taskman_event_conn, NULL, &port); taskman_exchange_end(exch); @@ -104,5 +106,5 @@ } - sysarg_t retval; + errno_t retval; async_wait_for(req, &retval); return retval; Index: uspace/lib/c/generic/taskman.c =================================================================== --- uspace/lib/c/generic/taskman.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/generic/taskman.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -103,6 +103,6 @@ assert(exch); - async_sess_t *sess = async_connect_me_to(EXCHANGE_ATOMIC, - exch, TASKMAN_CONNECT_TO_NS, 0, 0); + async_sess_t *sess = async_connect_me_to(exch, INTERFACE_NS, + TASKMAN_CONNECT_TO_NS, 0); async_exchange_end(exch); @@ -116,6 +116,6 @@ async_exch_t *exch = async_exchange_begin(session_taskman); - async_sess_t *sess = async_connect_me_to(EXCHANGE_SERIALIZE, - exch, TASKMAN_CONNECT_TO_LOADER, 0, 0); + async_sess_t *sess = async_connect_me_to(exch, INTERFACE_LOADER, + TASKMAN_CONNECT_TO_LOADER, 0); async_exchange_end(exch); @@ -136,11 +136,10 @@ * @return EOK on success, otherwise propagated error code */ -int taskman_intro_loader(void) +errno_t taskman_intro_loader(void) { assert(session_taskman); async_exch_t *exch = async_exchange_begin(session_taskman); - int rc = async_connect_to_me( - exch, TASKMAN_LOADER_CALLBACK, 0, 0, NULL, NULL); + errno_t rc = async_connect_to_me(exch, INTERFACE_LOADER, TASKMAN_LOADER_CALLBACK, 0); async_exchange_end(exch); @@ -152,5 +151,5 @@ * @return EOK on success, otherwise propagated error code */ -int taskman_intro_ns(void) +errno_t taskman_intro_ns(void) { assert(session_taskman); @@ -159,5 +158,5 @@ aid_t req = async_send_0(exch, TASKMAN_I_AM_NS, NULL); - int rc = async_connect_to_me(exch, 0, 0, 0, NULL, NULL); + errno_t rc = async_connect_to_me(exch, INTERFACE_NS, 0, 0); taskman_exchange_end(exch); @@ -166,5 +165,5 @@ } - sysarg_t retval; + errno_t retval; async_wait_for(req, &retval); return retval; Index: uspace/lib/c/generic/taskman_noasync.c =================================================================== --- uspace/lib/c/generic/taskman_noasync.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/generic/taskman_noasync.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -33,9 +33,10 @@ */ -#define LIBC_ASYNC_C_ -#include #include "private/async.h" #include "private/taskman.h" -#undef LIBC_ASYNC_C_ + +#undef _LIBC_ASYNC_H_ +#include +#define _LIBC_ASYNC_H_ #include @@ -50,12 +51,12 @@ * @return EOK on success, otherwise propagated error code */ -int taskman_intro_ns_noasync(void) +errno_t taskman_intro_ns_noasync(void) { assert(session_taskman); - int phone = async_session_phone(session_taskman); + cap_phone_handle_t phone = async_session_phone(session_taskman); - ipc_call_async_0(phone, TASKMAN_I_AM_NS, NULL, NULL, false); + ipc_call_async_0(phone, TASKMAN_I_AM_NS, NULL); - ipc_call_async_3(phone, IPC_M_CONNECT_TO_ME, 0, 0, 0, NULL, NULL, false); + ipc_call_async_3(phone, IPC_M_CONNECT_TO_ME, 0, 0, 0, NULL); /* @@ -67,12 +68,11 @@ -void task_retval_noasync(int retval) +void task_retval_noasync(errno_t retval) { assert(session_taskman); - int phone = async_session_phone(session_taskman); + cap_phone_handle_t phone = async_session_phone(session_taskman); /* Just send it and don't wait for an answer. */ - ipc_call_async_2(phone, TASKMAN_RETVAL, retval, false, - NULL, NULL, false); + ipc_call_async_2(phone, TASKMAN_RETVAL, retval, false, NULL); } Index: uspace/lib/c/include/adt/dyn_array.h =================================================================== --- uspace/lib/c/include/adt/dyn_array.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/include/adt/dyn_array.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -41,5 +41,5 @@ typedef struct { /** Data buffer of array */ - uint8_t *_data; + void *_data; /** Size on bytes of a single item */ size_t _item_size; Index: uspace/lib/c/include/async.h =================================================================== --- uspace/lib/c/include/async.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/include/async.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -132,5 +132,5 @@ extern void async_put_client_data_by_id(task_id_t); -extern void async_set_implicit_connection(async_client_conn_t); +extern void async_set_implicit_connection(async_port_handler_t); extern errno_t async_create_port(iface_t, async_port_handler_t, void *, Index: uspace/lib/c/include/ipc/services.h =================================================================== --- uspace/lib/c/include/ipc/services.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/include/ipc/services.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -55,4 +55,5 @@ #define SERVICE_NAME_CLIPBOARD "clipboard" #define SERVICE_NAME_CORECFG "corecfg" +#define SERVICE_NAME_DEVMAN "devman" #define SERVICE_NAME_DHCP "net/dhcp" #define SERVICE_NAME_DNSR "net/dnsr" Index: uspace/lib/c/include/task.h =================================================================== --- uspace/lib/c/include/task.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/include/task.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -76,5 +76,5 @@ /* Implemented in task_event.c */ -extern int task_register_event_handler(task_event_handler_t, bool); +extern errno_t task_register_event_handler(task_event_handler_t, bool); #endif Index: uspace/lib/c/include/taskman.h =================================================================== --- uspace/lib/c/include/taskman.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/c/include/taskman.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -40,8 +40,8 @@ /* Internal functions to be used by loader only */ extern async_sess_t *taskman_get_session(void); -extern int taskman_intro_loader(void); +extern errno_t taskman_intro_loader(void); /* Internal functions to be used by NS only */ -extern int taskman_intro_ns(void); +extern errno_t taskman_intro_ns(void); #endif Index: uspace/lib/conf/src/configuration.c =================================================================== --- uspace/lib/conf/src/configuration.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/conf/src/configuration.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -138,11 +138,11 @@ { bool value; - if (stricmp(string, "true") == 0 || - stricmp(string, "yes") == 0 || - stricmp(string, "1") == 0) { + if (str_casecmp(string, "true") == 0 || + str_casecmp(string, "yes") == 0 || + str_casecmp(string, "1") == 0) { value = true; - } else if (stricmp(string, "false") == 0 || - stricmp(string, "no") == 0 || - stricmp(string, "0") == 0) { + } else if (str_casecmp(string, "false") == 0 || + str_casecmp(string, "no") == 0 || + str_casecmp(string, "0") == 0) { value = false; } else { Index: uspace/lib/conf/src/ini.c =================================================================== --- uspace/lib/conf/src/ini.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/conf/src/ini.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -75,5 +75,5 @@ } -static size_t ini_section_ht_key_hash(void *key) +static size_t ini_section_ht_key_hash(const void *key) { /* Nameless default section */ @@ -91,5 +91,5 @@ } -static bool ini_section_ht_key_equal(void *key, const ht_link_t *item) +static bool ini_section_ht_key_equal(const void *key, const ht_link_t *item) { const char *name = key; @@ -119,5 +119,5 @@ } -static size_t ini_item_ht_key_hash(void *key) +static size_t ini_item_ht_key_hash(const void *key) { return hash_string((const char *)key); @@ -131,5 +131,5 @@ } -static bool ini_item_ht_key_equal(void *key, const ht_link_t *item) +static bool ini_item_ht_key_equal(const void *key, const ht_link_t *item) { return str_cmp((const char *)key, @@ -501,5 +501,5 @@ { iterator->cur_item = - hash_table_find_next(iterator->table, iterator->cur_item); + hash_table_find_next(iterator->table, iterator->first_item, iterator->cur_item); iterator->incremented = true; } Index: uspace/lib/sysman/include/sysman/ctl.h =================================================================== --- uspace/lib/sysman/include/sysman/ctl.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/sysman/include/sysman/ctl.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -33,15 +33,15 @@ #include -int sysman_unit_handle(const char *, unit_handle_t *); +errno_t sysman_unit_handle(const char *, unit_handle_t *); -int sysman_unit_start_by_name(const char *, int); -int sysman_unit_start(unit_handle_t, int); -int sysman_unit_stop(unit_handle_t, int); +errno_t sysman_unit_start_by_name(const char *, int); +errno_t sysman_unit_start(unit_handle_t, int); +errno_t sysman_unit_stop(unit_handle_t, int); -int sysman_get_units(unit_handle_t **, size_t *); +errno_t sysman_get_units(unit_handle_t **, size_t *); -int sysman_unit_get_name(unit_handle_t, char *, size_t); -int sysman_unit_get_state(unit_handle_t, unit_state_t *); +errno_t sysman_unit_get_name(unit_handle_t, char *, size_t); +errno_t sysman_unit_get_state(unit_handle_t, unit_state_t *); -int sysman_shutdown(void); +errno_t sysman_shutdown(void); #endif Index: uspace/lib/sysman/src/ctl.c =================================================================== --- uspace/lib/sysman/src/ctl.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/sysman/src/ctl.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -34,5 +34,5 @@ #include -int sysman_unit_handle(const char *unit_name, unit_handle_t *handle_ptr) +errno_t sysman_unit_handle(const char *unit_name, unit_handle_t *handle_ptr) { async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL); @@ -40,5 +40,5 @@ ipc_call_t call; aid_t req = async_send_0(exch, SYSMAN_CTL_UNIT_HANDLE, &call); - sysarg_t rc = async_data_write_start(exch, unit_name, str_size(unit_name)); + errno_t rc = async_data_write_start(exch, unit_name, str_size(unit_name)); sysman_exchange_end(exch); @@ -50,5 +50,5 @@ async_wait_for(req, &rc); if (rc == EOK) { - *handle_ptr = IPC_GET_ARG1(call); + *handle_ptr = ipc_get_arg1(&call); } return rc; @@ -64,10 +64,10 @@ * TODO convert to name->handle API */ -int sysman_unit_start_by_name(const char *unit_name, int flags) +errno_t sysman_unit_start_by_name(const char *unit_name, int flags) { async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL); aid_t req = async_send_1(exch, SYSMAN_CTL_UNIT_START_BY_NAME, flags, NULL); - sysarg_t rc = async_data_write_start(exch, unit_name, str_size(unit_name)); + errno_t rc = async_data_write_start(exch, unit_name, str_size(unit_name)); sysman_exchange_end(exch); @@ -81,9 +81,9 @@ } -int sysman_unit_start(unit_handle_t handle, int flags) -{ - async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL); - - int rc = async_req_2_0(exch, SYSMAN_CTL_UNIT_START, handle, flags); +errno_t sysman_unit_start(unit_handle_t handle, int flags) +{ + async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL); + + errno_t rc = async_req_2_0(exch, SYSMAN_CTL_UNIT_START, handle, flags); sysman_exchange_end(exch); @@ -91,9 +91,9 @@ } -int sysman_unit_stop(unit_handle_t handle, int flags) -{ - async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL); - - int rc = async_req_2_0(exch, SYSMAN_CTL_UNIT_STOP, handle, flags); +errno_t sysman_unit_stop(unit_handle_t handle, int flags) +{ + async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL); + + errno_t rc = async_req_2_0(exch, SYSMAN_CTL_UNIT_STOP, handle, flags); sysman_exchange_end(exch); @@ -101,5 +101,5 @@ } -static int sysman_get_units_once(sysarg_t *buf, size_t buf_size, +static errno_t sysman_get_units_once(sysarg_t *buf, size_t buf_size, size_t *act_size) { @@ -108,14 +108,14 @@ ipc_call_t answer; aid_t req = async_send_0(exch, SYSMAN_CTL_GET_UNITS, &answer); - int rc = async_data_read_start(exch, buf, buf_size); - - sysman_exchange_end(exch); - - if (rc != EOK) { - async_forget(req); - return rc; - } - - sysarg_t retval; + errno_t rc = async_data_read_start(exch, buf, buf_size); + + sysman_exchange_end(exch); + + if (rc != EOK) { + async_forget(req); + return rc; + } + + errno_t retval; async_wait_for(req, &retval); @@ -124,9 +124,9 @@ } - *act_size = IPC_GET_ARG1(answer); + *act_size = ipc_get_arg1(&answer); return EOK; } -int sysman_get_units(unit_handle_t **units_ptr, size_t *cnt_ptr) +errno_t sysman_get_units(unit_handle_t **units_ptr, size_t *cnt_ptr) { *units_ptr = NULL; @@ -138,5 +138,5 @@ while (true) { - int rc = sysman_get_units_once(units, alloc_size, &act_size); + errno_t rc = sysman_get_units_once(units, alloc_size, &act_size); if (rc != EOK) { return rc; @@ -159,5 +159,5 @@ } -int sysman_unit_get_name(unit_handle_t handle, char *buf, size_t buf_size) +errno_t sysman_unit_get_name(unit_handle_t handle, char *buf, size_t buf_size) { async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL); @@ -165,14 +165,14 @@ ipc_call_t answer; aid_t req = async_send_1(exch, SYSMAN_CTL_UNIT_GET_NAME, handle, &answer); - int rc = async_data_read_start(exch, buf, buf_size); - - sysman_exchange_end(exch); - - if (rc != EOK) { - async_forget(req); - return rc; - } - - sysarg_t retval; + errno_t rc = async_data_read_start(exch, buf, buf_size); + + sysman_exchange_end(exch); + + if (rc != EOK) { + async_forget(req); + return rc; + } + + errno_t retval; async_wait_for(req, &retval); @@ -184,19 +184,19 @@ } -int sysman_unit_get_state(unit_handle_t handle, unit_state_t *state) -{ - async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL); - int rc = async_req_1_1(exch, SYSMAN_CTL_UNIT_GET_STATE, handle, state); - sysman_exchange_end(exch); - - return rc; -} - -int sysman_shutdown(void) -{ - async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL); - int rc = async_req_0_0(exch, SYSMAN_CTL_SHUTDOWN); - sysman_exchange_end(exch); - - return rc; -} +errno_t sysman_unit_get_state(unit_handle_t handle, unit_state_t *state) +{ + async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL); + errno_t rc = async_req_1_1(exch, SYSMAN_CTL_UNIT_GET_STATE, handle, (sysarg_t *)state); + sysman_exchange_end(exch); + + return rc; +} + +errno_t sysman_shutdown(void) +{ + async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL); + errno_t rc = async_req_0_0(exch, SYSMAN_CTL_SHUTDOWN); + sysman_exchange_end(exch); + + return rc; +} Index: uspace/lib/sysman/src/sysman.c =================================================================== --- uspace/lib/sysman/src/sysman.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/lib/sysman/src/sysman.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -37,6 +37,5 @@ if (sysman_sess[iface] == NULL) { // TODO serialize vs parallel - sysman_sess[iface] = service_connect_blocking(EXCHANGE_SERIALIZE, - SERVICE_SYSMAN, iface, 0); + sysman_sess[iface] = service_connect_blocking(SERVICE_SYSMAN, INTERFACE_SYSMAN, iface); } Index: uspace/srv/devman/Makefile =================================================================== --- uspace/srv/devman/Makefile (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/devman/Makefile (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -29,6 +29,5 @@ USPACE_PREFIX = ../.. -LIBS = $(LIBSYSMAN_PREFIX)/libsysman.a -EXTRA_CFLAGS += -I$(LIBSYSMAN_PREFIX)/include +LIBS = sysman BINARY = devman STATIC_NEEDED = y Index: uspace/srv/devman/driver.c =================================================================== --- uspace/srv/devman/driver.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/devman/driver.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -34,11 +34,10 @@ #include #include -#include #include #include +#include #include #include #include -#include #include #include Index: uspace/srv/devman/drv_conn.c =================================================================== --- uspace/srv/devman/drv_conn.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/devman/drv_conn.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -41,5 +41,4 @@ #include #include -#include #include #include @@ -111,8 +110,8 @@ if (rc != EOK) { fibril_mutex_unlock(&driver->driver_mutex); - async_answer_0(callid, rc); + async_answer_0(call, rc); return NULL; } - sysman_main_exposee_added(unit_name, call->in_task_id); + sysman_main_exposee_added(unit_name, call->task_id); free(unit_name); Index: uspace/srv/hid/compositor/compositor.c =================================================================== --- uspace/srv/hid/compositor/compositor.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/hid/compositor/compositor.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -2304,5 +2304,5 @@ /* Finally, register compositor server. */ - async_set_fallback_port_handler(client_connection); + async_set_fallback_port_handler(client_connection, NULL); rc = loc_server_register(NAME); Index: uspace/srv/loader/main.c =================================================================== --- uspace/srv/loader/main.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/loader/main.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -56,5 +56,4 @@ #include #include -#include #include #include @@ -62,8 +61,6 @@ #include #include -#include #include #include -#include #include #include Index: uspace/srv/locsrv/Makefile =================================================================== --- uspace/srv/locsrv/Makefile (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/locsrv/Makefile (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -29,6 +29,5 @@ USPACE_PREFIX = ../.. -LIBS = $(LIBSYSMAN_PREFIX)/libsysman.a -EXTRA_CFLAGS += -I$(LIBSYSMAN_PREFIX)/include +LIBS = sysman BINARY = locsrv STATIC_NEEDED = y Index: uspace/srv/locsrv/locsrv.c =================================================================== --- uspace/srv/locsrv/locsrv.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/locsrv/locsrv.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -584,5 +584,5 @@ free(service); free(unit_name); - async_answer_0(iid, rc); + async_answer_0(icall, rc); return; } @@ -591,5 +591,5 @@ sysman_exposee_added(unit_name); } else { - sysman_main_exposee_added(unit_name, icall->in_task_id); + sysman_main_exposee_added(unit_name, icall->task_id); } free(unit_name); @@ -619,6 +619,5 @@ * */ -static void loc_service_unregister(ipc_callid_t iid, ipc_call_t *icall, - loc_server_t *server) +static void loc_service_unregister(ipc_call_t *icall, loc_server_t *server) { loc_service_t *svc; @@ -840,5 +839,5 @@ fibril_mutex_lock(&services_list_mutex); const loc_service_t *svc; - int flags = ipc_get_arg1(*icall); + int flags = ipc_get_arg1(icall); bool start_requested = false; @@ -889,7 +888,7 @@ finish: if (rc == EOK) { - async_answer_1(iid, EOK, svc->id); + async_answer_1(icall, EOK, svc->id); } else { - async_answer_0(iid, rc); + async_answer_0(icall, rc); } @@ -1669,4 +1668,6 @@ if (rc != EOK) { printf("%s: Error while registering broker service: %s\n", NAME, str_error(rc)); + return rc; + } /* Let sysman know we are broker */ Index: uspace/srv/ns/ns.c =================================================================== --- uspace/srv/ns/ns.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/ns/ns.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -75,7 +75,5 @@ break; - task_id_t id; errno_t retval; - service_t service; @@ -108,5 +106,6 @@ } - (void) ns_task_disconnect(&call); + /* TODO: Ignore so far, in future we might unregister services */ + //(void) ns_task_disconnect(&call); async_answer_0(&call, EOK); } Index: uspace/srv/sysman/Makefile =================================================================== --- uspace/srv/sysman/Makefile (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/Makefile (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -29,9 +29,6 @@ USPACE_PREFIX = ../.. -LIBS = $(LIBCONF_PREFIX)/libconf.a -EXTRA_CFLAGS += -I. \ - -I./units \ - -I$(LIBCONF_PREFIX)/include \ - -I$(LIBSYSMAN_PREFIX)/include +LIBS = conf sysman +EXTRA_CFLAGS = -I. -I./units BINARY = sysman STATIC_NEEDED = y Index: uspace/srv/sysman/connection_broker.c =================================================================== --- uspace/srv/sysman/connection_broker.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/connection_broker.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -36,8 +36,8 @@ #include "sysman.h" -static void sysman_broker_register(ipc_callid_t iid, ipc_call_t *icall) +static void sysman_broker_register(ipc_call_t *icall) { sysman_log(LVL_DEBUG2, "%s", __func__); - async_answer_0(iid, EOK); + async_answer_0(icall, EOK); /* * What exactly do here? Similar behavior that has locsrv with @@ -48,12 +48,12 @@ } -static void sysman_ipc_forwarded(ipc_callid_t iid, ipc_call_t *icall) +static void sysman_ipc_forwarded(ipc_call_t *icall) { sysman_log(LVL_DEBUG2, "%s", __func__); - async_answer_0(iid, ENOTSUP); + async_answer_0(icall, ENOTSUP); // TODO implement } -static void sysman_main_exposee_added(ipc_callid_t iid, ipc_call_t *icall) +static void sysman_main_exposee_added(ipc_call_t *icall) { char *unit_name = NULL; @@ -79,9 +79,9 @@ finish: - async_answer_0(iid, retval); + async_answer_0(icall, retval); free(unit_name); } -static void sysman_exposee_added(ipc_callid_t iid, ipc_call_t *icall) +static void sysman_exposee_added(ipc_call_t *icall) { char *exposee = NULL; @@ -100,48 +100,47 @@ finish: - async_answer_0(iid, retval); + async_answer_0(icall, retval); free(exposee); } -static void sysman_exposee_removed(ipc_callid_t iid, ipc_call_t *icall) +static void sysman_exposee_removed(ipc_call_t *icall) { sysman_log(LVL_DEBUG2, "%s", __func__); - async_answer_0(iid, ENOTSUP); + async_answer_0(icall, ENOTSUP); // TODO implement } -void sysman_connection_broker(ipc_callid_t iid, ipc_call_t *icall) +void sysman_connection_broker(ipc_call_t *icall) { sysman_log(LVL_DEBUG2, "%s", __func__); /* First, accept connection */ - async_answer_0(iid, EOK); + async_answer_0(icall, EOK); while (true) { ipc_call_t call; - ipc_callid_t callid = async_get_call(&call); - - if (!IPC_GET_IMETHOD(call)) { + + if (!async_get_call(&call) || !ipc_get_imethod(&call)) { /* Client disconnected */ break; } - switch (IPC_GET_IMETHOD(call)) { + switch (ipc_get_imethod(&call)) { case SYSMAN_BROKER_REGISTER: - sysman_broker_register(callid, &call); + sysman_broker_register(&call); break; case SYSMAN_BROKER_IPC_FWD: - sysman_ipc_forwarded(callid, &call); + sysman_ipc_forwarded(&call); break; case SYSMAN_BROKER_MAIN_EXP_ADDED: - sysman_main_exposee_added(callid, &call); + sysman_main_exposee_added(&call); break; case SYSMAN_BROKER_EXP_ADDED: - sysman_exposee_added(callid, &call); + sysman_exposee_added(&call); break; case SYSMAN_BROKER_EXP_REMOVED: - sysman_exposee_removed(callid, &call); + sysman_exposee_removed(&call); break; default: - async_answer_0(callid, ENOENT); + async_answer_0(&call, ENOENT); } } Index: uspace/srv/sysman/connection_broker.h =================================================================== --- uspace/srv/sysman/connection_broker.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/connection_broker.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -32,5 +32,5 @@ #include -extern void sysman_connection_broker(ipc_callid_t, ipc_call_t *); +extern void sysman_connection_broker(ipc_call_t *); #endif Index: uspace/srv/sysman/connection_ctl.c =================================================================== --- uspace/srv/sysman/connection_ctl.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/connection_ctl.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -43,11 +43,11 @@ // TODO possibly provide as type-safe function + macro in sysman.h for generic boxing -static ipc_callid_t *box_callid(ipc_callid_t iid) -{ - ipc_callid_t *result = malloc(sizeof(ipc_callid_t)); - if (result) { - *result = iid; - } - return result; +static ipc_call_t *box_callid(ipc_call_t *icall) +{ + ipc_call_t *copy = malloc(sizeof(ipc_call_t)); + if (copy) { + memcpy(copy, icall, sizeof(ipc_call_t)); + } + return copy; } @@ -58,13 +58,13 @@ assert(job->retval != JOB_UNDEFINED_); - ipc_callid_t *iid_ptr = arg; + ipc_call_t *icall = arg; // TODO use descriptive return value (probably refactor job retval) sysarg_t retval = (job->retval == JOB_OK) ? EOK : EIO; - async_answer_0(*iid_ptr, retval); - free(iid_ptr); + async_answer_0(icall, retval); + free(icall); job_del_ref(&job); } -static void sysman_unit_handle(ipc_callid_t iid, ipc_call_t *icall) +static void sysman_unit_handle(ipc_call_t *icall) { char *unit_name = NULL; @@ -84,14 +84,14 @@ } - async_answer_1(iid, EOK, unit->handle); + async_answer_1(icall, EOK, unit->handle); goto finish; fail: - async_answer_0(iid, retval); + async_answer_0(icall, retval); finish: free(unit_name); } -static void sysman_unit_start_by_name(ipc_callid_t iid, ipc_call_t *icall) +static void sysman_unit_start_by_name(ipc_call_t *icall) { char *unit_name = NULL; @@ -105,5 +105,5 @@ } - int flags = IPC_GET_ARG1(*icall); + int flags = ipc_get_arg1(icall); sysman_log(LVL_DEBUG2, "%s(%s, %x)", __func__, unit_name, flags); @@ -120,11 +120,11 @@ } - ipc_callid_t *iid_ptr = box_callid(iid); - if (iid_ptr == NULL) { + ipc_call_t *icall_copy = box_callid(icall); + if (icall_copy == NULL) { retval = ENOMEM; goto answer; } retval = sysman_run_job(unit, STATE_STARTED, 0, &answer_callback, - iid_ptr); + icall_copy); if (retval != EOK) { goto answer; @@ -135,17 +135,16 @@ answer: - async_answer_0(iid, retval); + async_answer_0(icall, retval); finish: free(unit_name); } -static void sysman_unit_operation(ipc_callid_t iid, ipc_call_t *icall, - unit_state_t state) +static void sysman_unit_operation(ipc_call_t *icall, unit_state_t state) { sysarg_t retval; - unit_handle_t handle = IPC_GET_ARG1(*icall); - int flags = IPC_GET_ARG2(*icall); - sysman_log(LVL_DEBUG2, "%s(%i, %x, %i)", __func__, handle, flags, state); + unit_handle_t handle = ipc_get_arg1(icall); + sysarg_t flags = ipc_get_arg2(icall); + sysman_log(LVL_DEBUG2, "%s(%p, %lx, %i)", __func__, icall->cap_handle, flags, state); unit_t *unit = repo_find_unit_by_handle(handle); @@ -160,11 +159,11 @@ } - ipc_callid_t *iid_ptr = box_callid(iid); - if (iid_ptr == NULL) { + ipc_call_t *icall_copy = box_callid(icall); + if (icall_copy == NULL) { retval = ENOMEM; goto answer; } retval = sysman_run_job(unit, state, 0, &answer_callback, - iid_ptr); + icall_copy); if (retval != EOK) { goto answer; @@ -175,15 +174,15 @@ answer: - async_answer_0(iid, retval); -} - -static void sysman_unit_start(ipc_callid_t iid, ipc_call_t *icall) -{ - sysman_unit_operation(iid, icall, STATE_STARTED); -} - -static void sysman_unit_stop(ipc_callid_t iid, ipc_call_t *icall) -{ - sysman_unit_operation(iid, icall, STATE_STOPPED); + async_answer_0(icall, retval); +} + +static void sysman_unit_start(ipc_call_t *icall) +{ + sysman_unit_operation(icall, STATE_STARTED); +} + +static void sysman_unit_stop(ipc_call_t *icall) +{ + sysman_unit_operation(icall, STATE_STOPPED); } @@ -210,14 +209,14 @@ } -static void sysman_get_units(ipc_callid_t iid, ipc_call_t *icall) -{ - ipc_callid_t callid; +static void sysman_get_units(ipc_call_t *icall) +{ + ipc_call_t call; size_t size; size_t act_size; int rc; - if (!async_data_read_receive(&callid, &size)) { - async_answer_0(callid, EREFUSED); - async_answer_0(iid, EREFUSED); + if (!async_data_read_receive(&call, &size)) { + async_answer_0(&call, EREFUSED); + async_answer_0(icall, EREFUSED); return; } @@ -226,6 +225,6 @@ unit_handle_t *handles = malloc(size); if (handles == NULL && size > 0) { - async_answer_0(callid, ENOMEM); - async_answer_0(iid, ENOMEM); + async_answer_0(&call, ENOMEM); + async_answer_0(icall, ENOMEM); return; } @@ -234,53 +233,53 @@ rc = fill_handles_buffer(handles, size, &act_size); if (rc != EOK) { - async_answer_0(callid, rc); - async_answer_0(iid, rc); + async_answer_0(&call, rc); + async_answer_0(icall, rc); return; } size_t real_size = min(act_size, size); - sysarg_t retval = async_data_read_finalize(callid, handles, real_size); + sysarg_t retval = async_data_read_finalize(&call, handles, real_size); free(handles); - async_answer_1(iid, retval, act_size); -} - -static void sysman_unit_get_name(ipc_callid_t iid, ipc_call_t *icall) -{ - ipc_callid_t callid; + async_answer_1(icall, retval, act_size); +} + +static void sysman_unit_get_name(ipc_call_t *icall) +{ + ipc_call_t call; size_t size; - if (!async_data_read_receive(&callid, &size)) { - async_answer_0(callid, EREFUSED); - async_answer_0(iid, EREFUSED); - return; - } - - unit_t *u = repo_find_unit_by_handle(IPC_GET_ARG1(*icall)); + if (!async_data_read_receive(&call, &size)) { + async_answer_0(&call, EREFUSED); + async_answer_0(icall, EREFUSED); + return; + } + + unit_t *u = repo_find_unit_by_handle(ipc_get_arg1(icall)); if (u == NULL) { - async_answer_0(callid, ENOENT); - async_answer_0(iid, ENOENT); + async_answer_0(&call, ENOENT); + async_answer_0(icall, ENOENT); return; } size_t real_size = min(str_size(u->name) + 1, size); - sysarg_t retval = async_data_read_finalize(callid, u->name, real_size); - - async_answer_0(iid, retval); -} - -static void sysman_unit_get_state(ipc_callid_t iid, ipc_call_t *icall) -{ - unit_t *u = repo_find_unit_by_handle(IPC_GET_ARG1(*icall)); + sysarg_t retval = async_data_read_finalize(&call, u->name, real_size); + + async_answer_0(icall, retval); +} + +static void sysman_unit_get_state(ipc_call_t *icall) +{ + unit_t *u = repo_find_unit_by_handle(ipc_get_arg1(icall)); if (u == NULL) { - async_answer_0(iid, ENOENT); + async_answer_0(icall, ENOENT); } else { - async_answer_1(iid, EOK, u->state); - } -} - -static void sysman_shutdown(ipc_callid_t iid, ipc_call_t *icall) -{ - int retval; + async_answer_1(icall, EOK, u->state); + } +} + +static void sysman_shutdown(ipc_call_t *icall) +{ + errno_t retval; unit_t *u = repo_find_unit_by_name(TARGET_SHUTDOWN); if (u == NULL) { @@ -293,49 +292,48 @@ finish: - async_answer_0(iid, retval); -} - -void sysman_connection_ctl(ipc_callid_t iid, ipc_call_t *icall) + async_answer_0(icall, retval); +} + +void sysman_connection_ctl(ipc_call_t *icall) { sysman_log(LVL_DEBUG2, "%s", __func__); /* First, accept connection */ - async_answer_0(iid, EOK); + async_answer_0(icall, EOK); while (true) { ipc_call_t call; - ipc_callid_t callid = async_get_call(&call); - - if (!IPC_GET_IMETHOD(call)) { + + if (!async_get_call(&call) || !ipc_get_imethod(&call)) { /* Client disconnected */ break; } - switch (IPC_GET_IMETHOD(call)) { + switch (ipc_get_imethod(&call)) { case SYSMAN_CTL_UNIT_HANDLE: - sysman_unit_handle(callid, &call); + sysman_unit_handle(&call); break; case SYSMAN_CTL_UNIT_START_BY_NAME: - sysman_unit_start_by_name(callid, &call); + sysman_unit_start_by_name(&call); break; case SYSMAN_CTL_UNIT_START: - sysman_unit_start(callid, &call); + sysman_unit_start(&call); break; case SYSMAN_CTL_UNIT_STOP: - sysman_unit_stop(callid, &call); + sysman_unit_stop(&call); break; case SYSMAN_CTL_GET_UNITS: - sysman_get_units(callid, &call); + sysman_get_units(&call); break; case SYSMAN_CTL_UNIT_GET_NAME: - sysman_unit_get_name(callid, &call); + sysman_unit_get_name(&call); break; case SYSMAN_CTL_UNIT_GET_STATE: - sysman_unit_get_state(callid, &call); + sysman_unit_get_state(&call); break; case SYSMAN_CTL_SHUTDOWN: - sysman_shutdown(callid, &call); + sysman_shutdown(&call); break; default: - async_answer_0(callid, ENOENT); + async_answer_0(&call, ENOENT); } } Index: uspace/srv/sysman/connection_ctl.h =================================================================== --- uspace/srv/sysman/connection_ctl.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/connection_ctl.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -32,5 +32,5 @@ #include -extern void sysman_connection_ctl(ipc_callid_t, ipc_call_t *); +extern void sysman_connection_ctl(ipc_call_t *); #endif Index: uspace/srv/sysman/edge.c =================================================================== --- uspace/srv/sysman/edge.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/edge.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -122,10 +122,10 @@ * @return EOK on success * @return ENOMEM - * @return EEXISTS + * @return EEXIST */ int edge_connect(unit_t *input, unit_t *output) { if (edge_extract_internal(input, output)) { - return EEXISTS; + return EEXIST; } Index: uspace/srv/sysman/job.c =================================================================== --- uspace/srv/sysman/job.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/job.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -31,4 +31,5 @@ #include #include +#include #include "repo.h" @@ -66,5 +67,5 @@ link_initialize(&job->job_queue); - atomic_set(&job->refcnt, 0); + atomic_store(&job->refcnt, 0); job->target_state = target_state; @@ -163,5 +164,5 @@ void job_add_ref(job_t *job) { - atomic_inc(&job->refcnt); + atomic_fetch_add(&job->refcnt, 1); } @@ -178,6 +179,7 @@ assert(job != NULL); - assert(atomic_get(&job->refcnt) > 0); - if (atomic_predec(&job->refcnt) == 0) { + assert(atomic_load(&job->refcnt) > 0); + atomic_fetch_sub(&job->refcnt, 1); + if (atomic_load(&job->refcnt) == 0) { job_destroy(job_ptr); } @@ -249,7 +251,7 @@ assert(!job->unit->job || job->unit->job == job); - sysman_log(LVL_DEBUG2, "%s(%p) %s ret %i, ref %i", + sysman_log(LVL_DEBUG2, "%s(%p) %s ret %i, ref %u", __func__, job, unit_name(job->unit), job->retval, - atomic_get(&job->refcnt)); + atomic_load(&job->refcnt)); job->state = JOB_FINISHED; Index: uspace/srv/sysman/job.h =================================================================== --- uspace/srv/sysman/job.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/job.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -32,5 +32,5 @@ #include #include -#include +#include #include @@ -58,5 +58,5 @@ struct job { link_t job_queue; - atomic_t refcnt; + atomic_uint refcnt; unit_state_t target_state; Index: uspace/srv/sysman/job_closure.c =================================================================== --- uspace/srv/sysman/job_closure.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/job_closure.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -345,5 +345,5 @@ dyn_array_foreach(*job_closure, job_t *, job_it) { sysman_log(LVL_DEBUG2, "%s\t%s, refs: %u", __func__, - unit_name((*job_it)->unit), atomic_get(&(*job_it)->refcnt)); + unit_name((*job_it)->unit), atomic_load(&(*job_it)->refcnt)); } } Index: uspace/srv/sysman/log.h =================================================================== --- uspace/srv/sysman/log.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/log.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -41,5 +41,5 @@ //#define sysman_log(level, fmt, ...) if(level > LVL_DEBUG2) printf("sysman: " fmt "\n", ##__VA_ARGS__) -extern void sysman_log(log_level_t, const char *, ...) PRINTF_ATTRIBUTE(2, 3); +extern void sysman_log(log_level_t, const char *, ...) _HELENOS_PRINTF_ATTRIBUTE(2, 3); extern void sysman_log_tofile(void); Index: uspace/srv/sysman/main.c =================================================================== --- uspace/srv/sysman/main.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/main.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -66,23 +66,23 @@ */ -static void sysman_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg) -{ - sysman_interface_t iface = IPC_GET_ARG1(*icall); +static void sysman_connection(ipc_call_t *icall, void *arg) +{ + sysman_interface_t iface = ipc_get_arg1(icall); switch (iface) { case SYSMAN_PORT_BROKER: - sysman_connection_broker(iid, icall); + sysman_connection_broker(icall); break; case SYSMAN_PORT_CTL: - sysman_connection_ctl(iid, icall); + sysman_connection_ctl(icall); break; default: /* Unknown interface */ - async_answer_0(iid, ENOENT); + async_answer_0(icall, ENOENT); } } /** Build hard coded configuration */ -static int create_entry_configuration(void) { - int rc; +static errno_t create_entry_configuration(void) { + errno_t rc; unit_t *mnt_initrd = NULL; unit_t *cfg_init = NULL; @@ -183,5 +183,5 @@ } - int rc = sysman_run_job(tgt, STATE_STARTED, 0, &sequence_job_handler, + errno_t rc = sysman_run_job(tgt, STATE_STARTED, 0, &sequence_job_handler, target_name_ptr); @@ -193,5 +193,4 @@ int main(int argc, char *argv[]) { - async_set_client_connection(sysman_connection); printf(NAME ": HelenOS system daemon\n"); @@ -207,5 +206,5 @@ * Create initial configuration while we are in a single fibril */ - int rc = create_entry_configuration(); + errno_t rc = create_entry_configuration(); if (rc != EOK) { sysman_log(LVL_FATAL, @@ -222,5 +221,5 @@ /* We're service too */ - rc = service_register(SERVICE_SYSMAN); + rc = service_register(SERVICE_SYSMAN, INTERFACE_SYSMAN, sysman_connection, NULL); if (rc != EOK) { sysman_log(LVL_FATAL, Index: uspace/srv/sysman/repo.c =================================================================== --- uspace/srv/sysman/repo.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/repo.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -30,4 +30,5 @@ #include #include +#include #include #include @@ -55,5 +56,5 @@ } -static size_t units_by_handle_ht_key_hash(void *key) +static size_t units_by_handle_ht_key_hash(const void *key) { return *(unit_handle_t *)key; @@ -67,5 +68,5 @@ } -static bool units_by_handle_ht_key_equal(void *key, const ht_link_t *item) +static bool units_by_handle_ht_key_equal(const void *key, const ht_link_t *item) { return *(unit_handle_t *)key == @@ -88,5 +89,5 @@ } -static size_t units_by_name_ht_key_hash(void *key) +static size_t units_by_name_ht_key_hash(const void *key) { return hash_string((const char *)key); @@ -100,5 +101,5 @@ } -static bool units_by_name_ht_key_equal(void *key, const ht_link_t *item) +static bool units_by_name_ht_key_equal(const void *key, const ht_link_t *item) { return str_cmp((const char *)key, @@ -166,5 +167,5 @@ return EOK; } else { - return EEXISTS; + return EEXIST; } } Index: uspace/srv/sysman/sm_task.c =================================================================== --- uspace/srv/sysman/sm_task.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/sm_task.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -210,7 +210,6 @@ } -int sm_task_start(void) -{ - int rc = task_register_event_handler(&sm_task_event_handler, true); - return rc; -} +errno_t sm_task_start(void) +{ + return task_register_event_handler(&sm_task_event_handler, true); +} Index: uspace/srv/sysman/sm_task.h =================================================================== --- uspace/srv/sysman/sm_task.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/sm_task.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -33,5 +33,5 @@ typedef struct sm_task_event sm_task_event_t; -extern int sm_task_start(void); +extern errno_t sm_task_start(void); #endif Index: uspace/srv/sysman/sysman.c =================================================================== --- uspace/srv/sysman/sysman.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/sysman.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -90,5 +90,5 @@ } -static size_t observed_objects_ht_key_hash(void *key) +static size_t observed_objects_ht_key_hash(const void *key) { void *object = *(void **) key; @@ -96,5 +96,5 @@ } -static bool observed_objects_ht_key_equal(void *key, const ht_link_t *item) +static bool observed_objects_ht_key_equal(const void *key, const ht_link_t *item) { void *object = *(void **)key; @@ -213,5 +213,5 @@ * @return EOK on successfully queued job */ -int sysman_run_job(unit_t *unit, unit_state_t target_state, int flags, +errno_t sysman_run_job(unit_t *unit, unit_state_t target_state, int flags, callback_handler_t callback, void *callback_arg) { @@ -279,7 +279,7 @@ * @return ENOMEM */ -int sysman_object_observer(void *object, callback_handler_t handler, void *data) -{ - int rc; +errno_t sysman_object_observer(void *object, callback_handler_t handler, void *data) +{ + errno_t rc; observed_object_t *observed_object = NULL; observed_object_t *new_observed_object = NULL; @@ -314,5 +314,5 @@ } -int sysman_move_observers(void *src_object, void *dst_object) +errno_t sysman_move_observers(void *src_object, void *dst_object) { ht_link_t *src_link = hash_table_find(&observed_objects, &src_object); Index: uspace/srv/sysman/sysman.h =================================================================== --- uspace/srv/sysman/sysman.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/sysman.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -51,11 +51,11 @@ extern void sysman_events_init(void); extern int sysman_events_loop(void *); -extern int sysman_run_job(unit_t *, unit_state_t, int, callback_handler_t, void *); +extern errno_t sysman_run_job(unit_t *, unit_state_t, int, callback_handler_t, void *); extern void sysman_raise_event(event_handler_t, void *); extern void sysman_process_queue(void); -extern int sysman_object_observer(void *, callback_handler_t, void *); -extern int sysman_move_observers(void *, void *); +extern errno_t sysman_object_observer(void *, callback_handler_t, void *); +extern errno_t sysman_move_observers(void *, void *); extern size_t sysman_observers_count(void *); Index: uspace/srv/sysman/test/job_closure.c =================================================================== --- uspace/srv/sysman/test/job_closure.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/test/job_closure.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -51,5 +51,5 @@ { if (expected->size != actual->size) { - printf("%s: |expected|, |actual| = %u, %u\n", + printf("%s: |expected|, |actual| = %lu, %lu\n", __func__, expected->size, actual->size); return false; Index: uspace/srv/sysman/units/unit_cfg.c =================================================================== --- uspace/srv/sysman/units/unit_cfg.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/units/unit_cfg.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -55,8 +55,8 @@ * @param[out] unit_ptr Unit loaded from the file. Undefined when function fails. */ -static int cfg_parse_file(const char *dirname, const char *filename, +static errno_t cfg_parse_file(const char *dirname, const char *filename, unit_t **unit_ptr) { - int rc = EOK; + errno_t rc = EOK; unit_t *new_unit = NULL; char *fn = NULL; @@ -86,5 +86,5 @@ if (u != NULL) { // TODO allow updating configuration of existing unit - rc = EEXISTS; + rc = EEXIST; goto finish; } else { @@ -136,5 +136,5 @@ list_foreach(text_parse.errors, link, text_parse_error_t, err) { sysman_log(LVL_WARN, - "Error (%i) when parsing '%s' on line %i.", + "Error (%i) when parsing '%s' on line %lu.", err->parse_errno, fn, err->lineno); } @@ -151,5 +151,5 @@ } -static int cfg_load_configuration(const char *path) +static errno_t cfg_load_configuration(const char *path) { DIR *dir; @@ -167,5 +167,5 @@ while ((de = readdir(dir))) { unit_t *unit = NULL; - int rc = cfg_parse_file(path, de->d_name, &unit); + errno_t rc = cfg_parse_file(path, de->d_name, &unit); if (rc != EOK) { sysman_log(LVL_WARN, "Cannot load unit from file %s/%s", @@ -183,5 +183,5 @@ closedir(dir); - int rc = repo_resolve_references(); + errno_t rc = repo_resolve_references(); if (rc != EOK) { repo_rollback(); @@ -207,5 +207,5 @@ } -static int unit_cfg_load(unit_t *unit, ini_configuration_t *ini_conf, +static errno_t unit_cfg_load(unit_t *unit, ini_configuration_t *ini_conf, text_parse_t *text_parse) { @@ -225,10 +225,10 @@ } -static int unit_cfg_start(unit_t *unit) -{ - unit_cfg_t *u_cfg = CAST_CFG(unit); - assert(u_cfg); - - int rc = cfg_load_configuration(u_cfg->path); +static errno_t unit_cfg_start(unit_t *unit) +{ + unit_cfg_t *u_cfg = CAST_CFG(unit); + assert(u_cfg); + + errno_t rc = cfg_load_configuration(u_cfg->path); if (rc == EOK) { @@ -241,5 +241,5 @@ } -static int unit_cfg_stop(unit_t *unit) +static errno_t unit_cfg_stop(unit_t *unit) { unit_cfg_t *u_cfg = CAST_CFG(unit); Index: uspace/srv/sysman/units/unit_mnt.c =================================================================== --- uspace/srv/sysman/units/unit_mnt.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/units/unit_mnt.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -130,5 +130,5 @@ } -static int unit_mnt_load(unit_t *unit, ini_configuration_t *ini_conf, +static errno_t unit_mnt_load(unit_t *unit, ini_configuration_t *ini_conf, text_parse_t *text_parse) { @@ -148,5 +148,5 @@ } -static int mount_exec(void *arg) +static errno_t mount_exec(void *arg) { mount_data_t *mnt_data = arg; @@ -156,5 +156,5 @@ mnt_data->flags, mnt_data->instance); - int rc = mount(mnt_data->type, mnt_data->mountpoint, mnt_data->device, + errno_t rc = vfs_mount_path(mnt_data->type, mnt_data->mountpoint, mnt_data->device, mnt_data->options ? mnt_data->options : "", mnt_data->flags, mnt_data->instance); @@ -188,5 +188,5 @@ } -static int unit_mnt_start(unit_t *unit) +static errno_t unit_mnt_start(unit_t *unit) { unit_mnt_t *u_mnt = CAST_MNT(unit); @@ -228,5 +228,5 @@ } -static int unit_mnt_stop(unit_t *unit) +static errno_t unit_mnt_stop(unit_t *unit) { unit_mnt_t *u_mnt = CAST_MNT(unit); @@ -245,5 +245,5 @@ * unmount synchronously in the event loop fibril. */ - int rc = unmount(u_mnt->mountpoint); + errno_t rc = vfs_unmount_path(u_mnt->mountpoint); if (rc == EOK) { Index: uspace/srv/sysman/units/unit_svc.c =================================================================== --- uspace/srv/sysman/units/unit_svc.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/sysman/units/unit_svc.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -32,4 +32,5 @@ #include #include +#include #include "log.h" @@ -58,5 +59,5 @@ } -static int unit_svc_load(unit_t *unit, ini_configuration_t *ini_conf, +static errno_t unit_svc_load(unit_t *unit, ini_configuration_t *ini_conf, text_parse_t *text_parse) { @@ -76,5 +77,5 @@ } -static int unit_svc_start(unit_t *unit) +static errno_t unit_svc_start(unit_t *unit) { unit_svc_t *u_svc = CAST_SVC(unit); @@ -84,5 +85,5 @@ assert(unit->state == STATE_STOPPED); - int rc = task_spawnv(&u_svc->main_task_id, NULL, u_svc->exec_start.path, + errno_t rc = task_spawnv(&u_svc->main_task_id, NULL, u_svc->exec_start.path, u_svc->exec_start.argv); @@ -100,5 +101,5 @@ */ if (str_cmp(unit->name, "devman.svc") == 0) { - async_usleep(100000); + fibril_usleep(100000); if (console_kcon()) { sysman_log(LVL_DEBUG2, "%s: Kconsole grabbed.", __func__); @@ -111,5 +112,5 @@ } -static int unit_svc_stop(unit_t *unit) +static errno_t unit_svc_stop(unit_t *unit) { unit_svc_t *u_svc = CAST_SVC(unit); @@ -129,5 +130,5 @@ } - int rc = task_kill(u_svc->main_task_id); + errno_t rc = task_kill(u_svc->main_task_id); if (rc != EOK) { Index: uspace/srv/taskman/event.c =================================================================== --- uspace/srv/taskman/event.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/taskman/event.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -49,5 +49,5 @@ task_id_t id; /**< Task ID who we wait for. */ task_id_t waiter_id; /**< Task ID who waits. */ - ipc_callid_t callid; /**< Call ID waiting for the event. */ + ipc_call_t *icall; /**< Call ID waiting for the event. */ int flags; /**< Wait flags. */ } pending_wait_t; @@ -59,5 +59,5 @@ static FIBRIL_RWLOCK_INITIALIZE(listeners_lock); -int event_init(void) +errno_t event_init(void) { list_initialize(&pending_waits); @@ -150,5 +150,5 @@ int match = notify_flags & pr->flags; // TODO why do I even accept such calls? - bool answer = !(pr->callid & IPC_CALLID_NOTIFICATION); + bool answer = !(pr->icall->flags & IPC_CALL_NOTIF); if (match == 0) { @@ -156,5 +156,5 @@ /* Nothing to wait for anymore */ if (answer) { - async_answer_0(pr->callid, EINTR); + async_answer_0(pr->icall, EINTR); } } else { @@ -165,9 +165,9 @@ if ((pr->flags & TASK_WAIT_BOTH) && match == TASK_WAIT_EXIT) { /* No sense to wait for both anymore */ - async_answer_1(pr->callid, EINTR, t->exit); + async_answer_1(pr->icall, EINTR, t->exit); } else { /* Send both exit status and retval, caller * should know what is valid */ - async_answer_3(pr->callid, EOK, t->exit, + async_answer_3(pr->icall, EOK, t->exit, t->retval, rest); } @@ -195,7 +195,7 @@ void event_register_listener(task_id_t id, bool past_events, async_sess_t *sess, - ipc_callid_t iid) -{ - int rc = EOK; + ipc_call_t *icall) +{ + errno_t rc = EOK; /* * We have lock of tasks structures so that we can guarantee @@ -219,5 +219,5 @@ * while we dump events. */ - async_answer_0(iid, rc); + async_answer_0(icall, rc); if (past_events) { task_foreach(&dump_walker, t->sess); @@ -228,9 +228,9 @@ fibril_rwlock_write_unlock(&task_hash_table_lock); if (rc != EOK) { - async_answer_0(iid, rc); - } -} - -void wait_for_task(task_id_t id, int flags, ipc_callid_t callid, + async_answer_0(icall, rc); + } +} + +void wait_for_task(task_id_t id, int flags, ipc_call_t *icall, task_id_t waiter_id) { @@ -244,5 +244,5 @@ if (t == NULL) { /* No such task exists. */ - async_answer_0(callid, ENOENT); + async_answer_0(icall, ENOENT); return; } @@ -250,5 +250,5 @@ if (t->exit != TASK_EXIT_RUNNING) { //TODO are flags BOTH processed correctly here? - async_answer_3(callid, EOK, t->exit, t->retval, 0); + async_answer_3(icall, EOK, t->exit, t->retval, 0); return; } @@ -267,5 +267,5 @@ } - int rc = EOK; + errno_t rc = EOK; if (pr == NULL) { pr = malloc(sizeof(pending_wait_t)); @@ -279,5 +279,5 @@ pr->waiter_id = waiter_id; pr->flags = flags; - pr->callid = callid; + pr->icall = icall; list_append(&pr->link, &pending_waits); @@ -288,5 +288,5 @@ * fibril). */ - rc = EEXISTS; + rc = EEXIST; } else { /* @@ -294,5 +294,5 @@ */ pr->flags &= ~TASK_WAIT_BOTH; // TODO maybe new flags should be set? - pr->callid = callid; + pr->icall = icall; } @@ -300,13 +300,13 @@ fibril_rwlock_write_unlock(&pending_wait_lock); // TODO why IPC_CALLID_NOTIFICATION? explain! - if (rc != EOK && !(callid & IPC_CALLID_NOTIFICATION)) { - async_answer_0(callid, rc); - } -} - - -int task_set_retval(task_id_t sender, int retval, bool wait_for_exit) -{ - int rc = EOK; + if (rc != EOK && !(icall->flags & IPC_CALL_NOTIF)) { + async_answer_0(icall, rc); + } +} + + +errno_t task_set_retval(task_id_t sender, int retval, bool wait_for_exit) +{ + errno_t rc = EOK; fibril_rwlock_write_lock(&task_hash_table_lock); Index: uspace/srv/taskman/event.h =================================================================== --- uspace/srv/taskman/event.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/taskman/event.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -39,11 +39,11 @@ #include -extern int event_init(void); +extern errno_t event_init(void); extern void event_register_listener(task_id_t, bool, async_sess_t *, - ipc_callid_t); -extern void dump_events(task_id_t, ipc_callid_t); -extern void wait_for_task(task_id_t, int, ipc_callid_t, task_id_t); -extern int task_set_retval(task_id_t, int, bool); + ipc_call_t *); +extern void dump_events(task_id_t, ipc_call_t *); +extern void wait_for_task(task_id_t, int, ipc_call_t *, task_id_t); +extern errno_t task_set_retval(task_id_t, int, bool); extern void task_terminated(task_id_t, exit_reason_t); Index: uspace/srv/taskman/main.c =================================================================== --- uspace/srv/taskman/main.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/taskman/main.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -71,13 +71,13 @@ * Static functions */ -static void connect_to_loader(ipc_callid_t iid, ipc_call_t *icall) -{ - DPRINTF("%s:%i from %llu\n", __func__, __LINE__, icall->in_task_id); +static void connect_to_loader(ipc_call_t *icall) +{ + DPRINTF("%s:%i from %llu\n", __func__, __LINE__, icall->task_id); /* We don't accept the connection request, we forward it instead to * freshly spawned loader. */ - int rc = loader_spawn("loader"); - - if (rc != EOK) { - async_answer_0(iid, rc); + errno_t rc = loader_spawn("loader"); + + if (rc != EOK) { + async_answer_0(icall, rc); return; } @@ -89,8 +89,8 @@ /* Forward the connection request (strip interface arg). */ async_exch_t *exch = async_exchange_begin(sess_ref->sess); - rc = async_forward_fast(iid, exch, - IPC_GET_ARG2(*icall), - IPC_GET_ARG3(*icall), - 0, IPC_FF_NONE); + rc = async_forward_1(icall, exch, + ipc_get_arg2(icall), + ipc_get_arg3(icall), + IPC_FF_NONE); async_exchange_end(exch); @@ -100,5 +100,5 @@ if (rc != EOK) { - async_answer_0(iid, rc); + async_answer_0(icall, rc); return; } @@ -107,7 +107,7 @@ } -static void connect_to_ns(ipc_callid_t iid, ipc_call_t *icall) -{ - DPRINTF("%s, %llu\n", __func__, icall->in_task_id); +static void connect_to_ns(ipc_call_t *icall) +{ + DPRINTF("%s, %llu\n", __func__, icall->task_id); /* Wait until we know NS */ @@ -120,27 +120,27 @@ /* Do not accept connection, forward it */ async_exch_t *exch = async_exchange_begin(session_ns); - int rc = async_forward_fast(iid, exch, 0, 0, 0, IPC_FF_NONE); + errno_t rc = async_forward_0(icall, exch, 0, IPC_FF_NONE); async_exchange_end(exch); if (rc != EOK) { - async_answer_0(iid, rc); - return; - } -} - -static void taskman_new_task(ipc_callid_t iid, ipc_call_t *icall) -{ - int rc = task_intro(icall->in_task_id); - async_answer_0(iid, rc); -} - -static void taskman_i_am_ns(ipc_callid_t iid, ipc_call_t *icall) -{ - DPRINTF("%s, %llu\n", __func__, icall->in_task_id); - int rc = EOK; + async_answer_0(icall, rc); + return; + } +} + +static void taskman_new_task(ipc_call_t *icall) +{ + errno_t rc = task_intro(icall->task_id); + async_answer_0(icall, rc); +} + +static void taskman_i_am_ns(ipc_call_t *icall) +{ + DPRINTF("%s, %llu\n", __func__, icall->task_id); + errno_t rc = EOK; fibril_mutex_lock(&session_ns_mtx); if (session_ns != NULL) { - rc = EEXISTS; + rc = EEXIST; goto finish; } @@ -157,63 +157,63 @@ finish: fibril_mutex_unlock(&session_ns_mtx); - async_answer_0(iid, rc); -} - -static void taskman_ctl_wait(ipc_callid_t iid, ipc_call_t *icall) + async_answer_0(icall, rc); +} + +static void taskman_ctl_wait(ipc_call_t *icall) { task_id_t id = (task_id_t) - MERGE_LOUP32(IPC_GET_ARG1(*icall), IPC_GET_ARG2(*icall)); - int flags = IPC_GET_ARG3(*icall); - task_id_t waiter_id = icall->in_task_id; - - wait_for_task(id, flags, iid, waiter_id); -} - -static void taskman_ctl_retval(ipc_callid_t iid, ipc_call_t *icall) -{ - task_id_t sender = icall->in_task_id; - int retval = IPC_GET_ARG1(*icall); - bool wait_for_exit = IPC_GET_ARG2(*icall); + MERGE_LOUP32(ipc_get_arg1(icall), ipc_get_arg2(icall)); + int flags = ipc_get_arg3(icall); + task_id_t waiter_id = icall->task_id; + + wait_for_task(id, flags, icall, waiter_id); +} + +static void taskman_ctl_retval(ipc_call_t *icall) +{ + task_id_t sender = icall->task_id; + int retval = ipc_get_arg1(icall); + bool wait_for_exit = ipc_get_arg2(icall); DPRINTF("%s:%i from %llu/%i\n", __func__, __LINE__, sender, retval); - int rc = task_set_retval(sender, retval, wait_for_exit); - async_answer_0(iid, rc); -} - -static void taskman_ctl_ev_callback(ipc_callid_t iid, ipc_call_t *icall) -{ - DPRINTF("%s:%i from %llu\n", __func__, __LINE__, icall->in_task_id); - - bool past_events = IPC_GET_ARG1(*icall); + errno_t rc = task_set_retval(sender, retval, wait_for_exit); + async_answer_0(icall, rc); +} + +static void taskman_ctl_ev_callback(ipc_call_t *icall) +{ + DPRINTF("%s:%i from %llu\n", __func__, __LINE__, icall->task_id); + + bool past_events = ipc_get_arg1(icall); /* Atomic -- will be used for notifications only */ async_sess_t *sess = async_callback_receive(EXCHANGE_ATOMIC); if (sess == NULL) { - async_answer_0(iid, ENOMEM); - return; - } - - event_register_listener(icall->in_task_id, past_events, sess, iid); -} - -static void task_exit_event(ipc_callid_t iid, ipc_call_t *icall, void *arg) -{ - task_id_t id = MERGE_LOUP32(IPC_GET_ARG1(*icall), IPC_GET_ARG2(*icall)); - exit_reason_t exit_reason = IPC_GET_ARG3(*icall); + async_answer_0(icall, ENOMEM); + return; + } + + event_register_listener(icall->task_id, past_events, sess, icall); +} + +static void task_exit_event(ipc_call_t *icall, void *arg) +{ + task_id_t id = MERGE_LOUP32(ipc_get_arg1(icall), ipc_get_arg2(icall)); + exit_reason_t exit_reason = ipc_get_arg3(icall); DPRINTF("%s:%i from %llu/%i\n", __func__, __LINE__, id, exit_reason); task_terminated(id, exit_reason); } -static void task_fault_event(ipc_callid_t iid, ipc_call_t *icall, void *arg) -{ - task_id_t id = MERGE_LOUP32(IPC_GET_ARG1(*icall), IPC_GET_ARG2(*icall)); +static void task_fault_event(ipc_call_t *icall, void *arg) +{ + task_id_t id = MERGE_LOUP32(ipc_get_arg1(icall), ipc_get_arg2(icall)); DPRINTF("%s:%i from %llu\n", __func__, __LINE__, id); task_failed(id); } -static void loader_callback(ipc_callid_t iid, ipc_call_t *icall) -{ - DPRINTF("%s:%i from %llu\n", __func__, __LINE__, icall->in_task_id); +static void loader_callback(ipc_call_t *icall) +{ + DPRINTF("%s:%i from %llu\n", __func__, __LINE__, icall->task_id); // TODO check that loader is expected, would probably discard prodcons // scheme @@ -222,5 +222,5 @@ sess_ref_t *sess_ref = malloc(sizeof(sess_ref_t)); if (sess_ref == NULL) { - async_answer_0(iid, ENOMEM); + async_answer_0(icall, ENOMEM); } @@ -228,9 +228,9 @@ sess_ref->sess = async_callback_receive_start(EXCHANGE_ATOMIC, icall); if (sess_ref->sess == NULL) { - async_answer_0(iid, EINVAL); - return; - } - - async_answer_0(iid, EOK); + async_answer_0(icall, EINVAL); + return; + } + + async_answer_0(icall, EOK); /* Notify spawners */ @@ -239,21 +239,21 @@ } -static bool handle_call(ipc_callid_t iid, ipc_call_t *icall) -{ - switch (IPC_GET_IMETHOD(*icall)) { +static bool handle_call(ipc_call_t *icall) +{ + switch (ipc_get_imethod(icall)) { case TASKMAN_NEW_TASK: - taskman_new_task(iid, icall); + taskman_new_task(icall); break; case TASKMAN_I_AM_NS: - taskman_i_am_ns(iid, icall); + taskman_i_am_ns(icall); break; case TASKMAN_WAIT: - taskman_ctl_wait(iid, icall); + taskman_ctl_wait(icall); break; case TASKMAN_RETVAL: - taskman_ctl_retval(iid, icall); + taskman_ctl_retval(icall); break; case TASKMAN_EVENT_CALLBACK: - taskman_ctl_ev_callback(iid, icall); + taskman_ctl_ev_callback(icall); break; default: @@ -263,5 +263,5 @@ } -static bool handle_implicit_call(ipc_callid_t iid, ipc_call_t *icall) +static bool handle_implicit_call(ipc_call_t *icall) { /*DPRINTF("%s:%i %i(%i) from %llu\n", __func__, __LINE__, @@ -270,14 +270,14 @@ icall->in_task_id);*/ - if (IPC_GET_IMETHOD(*icall) < IPC_FIRST_USER_METHOD) { - switch (IPC_GET_ARG1(*icall)) { + if (ipc_get_imethod(icall) < IPC_FIRST_USER_METHOD) { + switch (ipc_get_arg1(icall)) { case TASKMAN_CONNECT_TO_NS: - connect_to_ns(iid, icall); + connect_to_ns(icall); break; case TASKMAN_CONNECT_TO_LOADER: - connect_to_loader(iid, icall); + connect_to_loader(icall); break; case TASKMAN_LOADER_CALLBACK: - loader_callback(iid, icall); + loader_callback(icall); break; default: @@ -286,5 +286,5 @@ } } else { - return handle_call(iid, icall); + return handle_call(icall); } @@ -292,8 +292,8 @@ } -static void implicit_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg) -{ - if (!handle_implicit_call(iid, icall)) { - async_answer_0(iid, ENOTSUP); +static void implicit_connection(ipc_call_t *icall, void *arg) +{ + if (!handle_implicit_call(icall)) { + async_answer_0(icall, ENOTSUP); return; } @@ -301,13 +301,12 @@ while (true) { ipc_call_t call; - ipc_callid_t callid = async_get_call(&call); - - if (!IPC_GET_IMETHOD(call)) { + + if (!async_get_call(&call) || !ipc_get_imethod(&call)) { /* Client disconnected */ break; } - if (!handle_implicit_call(callid, &call)) { - async_answer_0(callid, ENOTSUP); + if (!handle_implicit_call(&call)) { + async_answer_0(icall, ENOTSUP); break; } @@ -315,5 +314,5 @@ } -static void taskman_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg) +static void taskman_connection(ipc_call_t *icall, void *arg) { /* @@ -324,7 +323,7 @@ * "listening" on such connections. */ - if (!handle_implicit_call(iid, icall)) { - /* If cannot handle connection requst, give up trying */ - async_answer_0(iid, EHANGUP); + if (!handle_implicit_call(icall)) { + /* If cannot handle connection request, give up trying */ + async_answer_0(icall, EHANGUP); return; } @@ -339,5 +338,5 @@ /* Initialization */ prodcons_initialize(&sess_queue); - int rc = tasks_init(); + errno_t rc = tasks_init(); if (rc != EOK) { return rc; @@ -368,5 +367,5 @@ /* Start sysman server */ async_set_implicit_connection(implicit_connection); - async_set_client_connection(taskman_connection); + async_set_fallback_port_handler(taskman_connection, NULL); printf(NAME ": Accepting connections\n"); Index: uspace/srv/taskman/task.c =================================================================== --- uspace/srv/taskman/task.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/taskman/task.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -57,5 +57,5 @@ */ -static size_t ht_task_key_hash(void *key) +static size_t ht_task_key_hash(const void *key) { return *(task_id_t*)key; @@ -68,5 +68,5 @@ } -static bool ht_task_key_equal(void *key, const ht_link_t *item) +static bool ht_task_key_equal(const void *key, const ht_link_t *item) { task_t *ht = hash_table_get_inst(item, task_t, link); @@ -199,5 +199,5 @@ task_t *t = task_get_by_id(id); if (t != NULL) { - rc = EEXISTS; + rc = EEXIST; goto finish; } Index: uspace/srv/vfs/Makefile =================================================================== --- uspace/srv/vfs/Makefile (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/vfs/Makefile (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -29,6 +29,6 @@ USPACE_PREFIX = ../.. -LIBS = $(LIBSYSMAN_PREFIX)/libsysman.a -EXTRA_CFLAGS += -I$(LIBSYSMAN_PREFIX)/include +LIBS = sysman +EXTRA_CFLAGS += -I$(USPACE_PREFIX)/lib/sysman/include BINARY = vfs STATIC_NEEDED = y Index: uspace/srv/vfs/vfs.c =================================================================== --- uspace/srv/vfs/vfs.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/vfs/vfs.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -43,5 +43,5 @@ #include #include -#include +#include #include #include Index: uspace/srv/vfs/vfs.h =================================================================== --- uspace/srv/vfs/vfs.h (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/vfs/vfs.h (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -178,4 +178,5 @@ extern fs_handle_t fs_name_to_handle(const char *, unsigned int instance, bool); extern vfs_info_t *fs_handle_to_info(fs_handle_t); +extern int vfs_get_fstypes(vfs_fstypes_t *); extern errno_t fs_unit_name(const char *, unsigned int, char **); Index: uspace/srv/vfs/vfs_ops.c =================================================================== --- uspace/srv/vfs/vfs_ops.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/vfs/vfs_ops.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -50,8 +50,11 @@ #include #include +#include /* Forward declarations of static functions. */ static errno_t vfs_truncate_internal(fs_handle_t, service_id_t, fs_index_t, aoff64_t); + +static errno_t vfs_fs_request_start(const char *fs_name, unsigned int instance); /** @@ -144,16 +147,11 @@ */ fibril_mutex_unlock(&fs_list_lock); - rc = vfs_fs_request_start(fs_name, instance); + errno_t rc = vfs_fs_request_start(fsname, instance); fibril_mutex_lock(&fs_list_lock); if (rc != EOK) { - fibril_mutex_unlock(&fs_list_lock); - async_answer_0(callid, rc); - async_answer_0(rid, rc); - free(mp); - free(fs_name); - free(opts); - return; + return rc; } + /* * Succesful start request, new server should be @@ -216,5 +214,5 @@ } -static int vfs_fs_request_start(const char *fs_name, unsigned int instance) +static errno_t vfs_fs_request_start(const char *fs_name, unsigned int instance) { char *unit_name = NULL; Index: uspace/srv/vfs/vfs_register.c =================================================================== --- uspace/srv/vfs/vfs_register.c (revision f92b3153d0b067cd973af2740c7fb28c0d01ecfe) +++ uspace/srv/vfs/vfs_register.c (revision 241f19855d1d9af65e95690ac5eb1dd1facffd0c) @@ -40,5 +40,5 @@ #include #include -#include +#include #include #include @@ -169,8 +169,8 @@ fibril_mutex_unlock(&fs_list_lock); free(fs_info); - async_answer_0(rid, rc); - return; - } - sysman_main_exposee_added(unit_name, request->in_task_id); + async_answer_0(req, rc); + return; + } + sysman_main_exposee_added(unit_name, req->task_id); free(unit_name);