Index: uspace/lib/c/generic/adt/dyn_array.c
===================================================================
--- uspace/lib/c/generic/adt/dyn_array.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/lib/c/generic/adt/dyn_array.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -44,5 +44,5 @@
 #include <stdlib.h>
 
-static int dyn_array_realloc(dyn_array_t *da, size_t capacity)
+static errno_t dyn_array_realloc(dyn_array_t *da, size_t capacity)
 {
 	if (capacity == da->capacity) {
@@ -70,5 +70,5 @@
 	assert(index < da->size);
 	_dyn_array_unshift(da, index, 1);
-	int rc = dyn_array_reserve(da, da->size);
+	errno_t rc = dyn_array_reserve(da, da->size);
 	assert(rc == EOK);
 }
@@ -92,5 +92,5 @@
 
 	_dyn_array_unshift(da, begin, end - begin);
-	int rc = dyn_array_reserve(da, da->size);
+	errno_t rc = dyn_array_reserve(da, da->size);
 	assert(rc == EOK);
 }
@@ -104,9 +104,9 @@
  * @return ENOMEM when allocation fails
  */
-int dyn_array_concat(dyn_array_t *da1, dyn_array_t *da2)
+errno_t dyn_array_concat(dyn_array_t *da1, dyn_array_t *da2)
 {
 	assert(da1->_item_size == da2->_item_size);
 
-	int rc = dyn_array_reserve(da1, da1->size + da2->size);
+	errno_t rc = dyn_array_reserve(da1, da1->size + da2->size);
 	if (rc != EOK) {
 		return rc;
@@ -129,5 +129,5 @@
  * @return ENOMEM
  */
-int dyn_array_reserve(dyn_array_t *da, size_t capacity)
+errno_t dyn_array_reserve(dyn_array_t *da, size_t capacity)
 {
 	const size_t factor = 2;
Index: uspace/lib/c/include/adt/dyn_array.h
===================================================================
--- uspace/lib/c/include/adt/dyn_array.h	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/lib/c/include/adt/dyn_array.h	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -36,4 +36,5 @@
 #define LIBC_DYN_ARRAY_H_
 
+#include <errno.h>
 #include <stdbool.h>
 #include <stddef.h>
@@ -83,5 +84,5 @@
  	size_t _index = (index);                                               \
  	dyn_array_t *_da = (dyn_array);                                        \
-	int rc = dyn_array_reserve(_da, _da->size + 1);                        \
+	errno_t rc = dyn_array_reserve(_da, _da->size + 1);                        \
 	if (!rc) {                                                             \
 		_dyn_array_shift(_da, _index, 1);                              \
@@ -134,6 +135,6 @@
 void dyn_array_clear(dyn_array_t *);
 void dyn_array_clear_range(dyn_array_t *, size_t, size_t);
-extern int dyn_array_concat(dyn_array_t *, dyn_array_t *);
-extern int dyn_array_reserve(dyn_array_t *, size_t);
+extern errno_t dyn_array_concat(dyn_array_t *, dyn_array_t *);
+extern errno_t dyn_array_reserve(dyn_array_t *, size_t);
 
 extern void _dyn_array_initialize(dyn_array_t *, size_t);
Index: uspace/lib/c/include/taskman_noasync.h
===================================================================
--- uspace/lib/c/include/taskman_noasync.h	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/lib/c/include/taskman_noasync.h	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -37,5 +37,5 @@
 
 /* Internal functions to be used by NS only */
-extern int taskman_intro_ns_noasync(void);
+extern errno_t taskman_intro_ns_noasync(void);
 
 extern void task_retval_noasync(int);
Index: uspace/lib/c/test/dyn_array.c
===================================================================
--- uspace/lib/c/test/dyn_array.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/lib/c/test/dyn_array.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -41,5 +41,5 @@
 {
 	dyn_array_initialize(&da, data_t);
-	int rc = dyn_array_reserve(&da, 3);
+	errno_t rc = dyn_array_reserve(&da, 3);
 	assert(rc == EOK);
 }
Index: uspace/srv/sysman/connection_broker.c
===================================================================
--- uspace/srv/sysman/connection_broker.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/connection_broker.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -60,5 +60,5 @@
 	sysarg_t retval;
 
-	int rc = async_data_write_accept((void **) &unit_name, true,
+	errno_t rc = async_data_write_accept((void **) &unit_name, true,
 	    0, 0, 0, NULL);
 	if (rc != EOK) {
@@ -89,5 +89,5 @@
 
 	/* Just accept data and further not supported. */
-	int rc = async_data_write_accept((void **) &exposee, true,
+	errno_t rc = async_data_write_accept((void **) &exposee, true,
 	    0, 0, 0, NULL);
 	if (rc != EOK) {
Index: uspace/srv/sysman/connection_ctl.c
===================================================================
--- uspace/srv/sysman/connection_ctl.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/connection_ctl.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -70,5 +70,5 @@
 	sysarg_t retval;
 
-	int rc = async_data_write_accept((void **) &unit_name, true,
+	errno_t rc = async_data_write_accept((void **) &unit_name, true,
 	    0, 0, 0, NULL);
 	if (rc != EOK) {
@@ -97,5 +97,5 @@
 	sysarg_t retval;
 
-	int rc = async_data_write_accept((void **) &unit_name, true,
+	errno_t rc = async_data_write_accept((void **) &unit_name, true,
 	    0, 0, 0, NULL);
 	if (rc != EOK) {
@@ -186,5 +186,5 @@
 }
 
-static int fill_handles_buffer(unit_handle_t *buffer, size_t size,
+static errno_t fill_handles_buffer(unit_handle_t *buffer, size_t size,
     size_t *act_size)
 {
@@ -213,5 +213,5 @@
 	size_t size;
 	size_t act_size;
-	int rc;
+	errno_t rc;
 
 	if (!async_data_read_receive(&call, &size)) {
Index: uspace/srv/sysman/edge.c
===================================================================
--- uspace/srv/sysman/edge.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/edge.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -77,7 +77,7 @@
 }
 
-int edge_sprout_out(unit_t *input, const char *output_name)
+errno_t edge_sprout_out(unit_t *input, const char *output_name)
 {
-	int rc;
+	errno_t rc;
 	unit_edge_t *e = edge_create();
 
@@ -123,5 +123,5 @@
  * @return        EEXIST
  */
-int edge_connect(unit_t *input, unit_t *output)
+errno_t edge_connect(unit_t *input, unit_t *output)
 {
 	if (edge_extract_internal(input, output)) {
Index: uspace/srv/sysman/edge.h
===================================================================
--- uspace/srv/sysman/edge.h	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/edge.h	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -65,8 +65,8 @@
 extern void edge_destroy(unit_edge_t **);
 
-extern int edge_sprout_out(unit_t *, const char *);
+extern errno_t edge_sprout_out(unit_t *, const char *);
 extern void edge_resolve_output(unit_edge_t *, unit_t *);
 
-extern int edge_connect(unit_t *, unit_t *);
+extern errno_t edge_connect(unit_t *, unit_t *);
 extern void edge_remove(unit_edge_t **);
 
Index: uspace/srv/sysman/job.c
===================================================================
--- uspace/srv/sysman/job.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/job.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -198,5 +198,5 @@
 	}
 
-	int rc;
+	errno_t rc;
 	// TODO put here similar evaluation as in job_check
 	//      goal is to have job_run "idempotent"
Index: uspace/srv/sysman/job_closure.c
===================================================================
--- uspace/srv/sysman/job_closure.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/job_closure.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -51,5 +51,5 @@
 	 * return result of visit (error stops further traversal)
 	 */
-	int (*visit)(unit_t *, unit_edge_t *, bfs_ops_t *, void *);
+	errno_t (*visit)(unit_t *, unit_edge_t *, bfs_ops_t *, void *);
 
 	/** Clean units remaining in BFS queue after error */
@@ -61,10 +61,10 @@
  */
 
-static int job_add_blocked_job(job_t *blocking_job, job_t *blocked_job)
+static errno_t job_add_blocked_job(job_t *blocking_job, job_t *blocked_job)
 {
 	assert(blocking_job->blocked_jobs.size ==
 	    blocking_job->blocked_jobs_count);
 
-	int rc = dyn_array_append(&blocking_job->blocked_jobs, job_t *,
+	errno_t rc = dyn_array_append(&blocking_job->blocked_jobs, job_t *,
 	    blocked_job);
 	if (rc != EOK) {
@@ -86,8 +86,8 @@
  * @return EOK on success
  */
-static int visit_propagate_job(unit_t *u, unit_edge_t *e, bfs_ops_t *ops,
+static errno_t visit_propagate_job(unit_t *u, unit_edge_t *e, bfs_ops_t *ops,
     void *arg)
 {
-	int rc = EOK;
+	errno_t rc = EOK;
 	job_t *created_job = NULL;
 	job_closure_t *closure = arg;
@@ -138,7 +138,7 @@
 }
 
-static int visit_isolate(unit_t *u, unit_edge_t *e, bfs_ops_t *ops, void *arg)
-{
-	int rc = EOK;
+static errno_t visit_isolate(unit_t *u, unit_edge_t *e, bfs_ops_t *ops, void *arg)
+{
+	errno_t rc = EOK;
 	job_t *created_job = NULL;
 	job_closure_t *closure = arg;
@@ -187,8 +187,8 @@
 }
 
-static int bfs_traverse_component_internal(unit_t *origin, bfs_ops_t *ops,
+static errno_t bfs_traverse_component_internal(unit_t *origin, bfs_ops_t *ops,
     void *arg)
 {
-	int rc;
+	errno_t rc;
 	list_t units_fifo;
 	list_initialize(&units_fifo);
@@ -247,5 +247,5 @@
 }
 
-static int bfs_traverse_component(unit_t *origin, bfs_ops_t *ops, void *arg)
+static errno_t bfs_traverse_component(unit_t *origin, bfs_ops_t *ops, void *arg)
 {
 	/* Check invariant */
@@ -253,5 +253,5 @@
 		assert(u->bfs_tag == false);
 	}
-	int rc = bfs_traverse_component_internal(origin, ops, arg);
+	errno_t rc = bfs_traverse_component_internal(origin, ops, arg);
 
 	/* Clean after ourselves (BFS tag jobs) */
@@ -262,5 +262,5 @@
 }
 
-static int bfs_traverse_all(bfs_ops_t *ops, void *arg)
+static errno_t bfs_traverse_all(bfs_ops_t *ops, void *arg)
 {
 	/* Check invariant */
@@ -268,5 +268,5 @@
 		assert(u->bfs_tag == false);
 	}
-	int rc = EOK;
+	errno_t rc = EOK;
 
 	repo_foreach(origin) {
@@ -299,5 +299,5 @@
  * @return EOK on success otherwise propagated error
  */
-int job_create_closure(job_t *main_job, job_closure_t *job_closure, int flags)
+errno_t job_create_closure(job_t *main_job, job_closure_t *job_closure, int flags)
 {
 	sysman_log(LVL_DEBUG2, "%s(%s)", __func__, unit_name(main_job->unit));
@@ -308,5 +308,5 @@
 	}
 
-	int rc = dyn_array_append(job_closure, job_t *, main_job);
+	errno_t rc = dyn_array_append(job_closure, job_t *, main_job);
 	if (rc != EOK) {
 		return rc;
Index: uspace/srv/sysman/job_closure.h
===================================================================
--- uspace/srv/sysman/job_closure.h	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/job_closure.h	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -38,5 +38,5 @@
 typedef dyn_array_t job_closure_t;
 
-extern int job_create_closure(job_t *, job_closure_t *, int);
+extern errno_t job_create_closure(job_t *, job_closure_t *, int);
 
 #endif
Index: uspace/srv/sysman/job_queue.c
===================================================================
--- uspace/srv/sysman/job_queue.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/job_queue.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -103,5 +103,5 @@
  * @return error code on fail
  */
-static int job_pre_merge(job_t *trunk, job_t *other)
+static errno_t job_pre_merge(job_t *trunk, job_t *other)
 {
 	assert(trunk->unit == other->unit);
@@ -110,5 +110,5 @@
 	assert(other->merged_into == NULL);
 
-	int rc = dyn_array_concat(&trunk->blocked_jobs, &other->blocked_jobs);
+	errno_t rc = dyn_array_concat(&trunk->blocked_jobs, &other->blocked_jobs);
 	if (rc != EOK) {
 		return rc;
@@ -134,5 +134,5 @@
 	 */
 	size_t observers_refs = sysman_observers_count(other);
-	int rc = sysman_move_observers(other, trunk);
+	errno_t rc = sysman_move_observers(other, trunk);
 	assert(rc == EOK);
 
@@ -166,8 +166,8 @@
  * @return EBUSY when any job in closure is conflicting
  */
-int job_queue_add_closure(job_closure_t *closure)
+errno_t job_queue_add_closure(job_closure_t *closure)
 {
 	bool has_error = false;
-	int rc = EOK;
+	errno_t rc = EOK;
 
 	/* Check consistency with existing jobs. */
Index: uspace/srv/sysman/job_queue.h
===================================================================
--- uspace/srv/sysman/job_queue.h	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/job_queue.h	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -33,5 +33,5 @@
 
 extern void job_queue_init(void);
-extern int job_queue_add_closure(job_closure_t *);
+extern errno_t job_queue_add_closure(job_closure_t *);
 extern void job_queue_process(void);
 
Index: uspace/srv/sysman/repo.c
===================================================================
--- uspace/srv/sysman/repo.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/repo.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -151,5 +151,5 @@
 }
 
-int repo_add_unit(unit_t *unit)
+errno_t repo_add_unit(unit_t *unit)
 {
 	assert(unit);
@@ -172,5 +172,5 @@
 }
 
-int repo_remove_unit(unit_t *unit)
+errno_t repo_remove_unit(unit_t *unit)
 {
 	unit->repo_state = REPO_ZOMBIE;
@@ -283,5 +283,5 @@
  * @return ENOENT  when one or more resolution fails, information is logged
  */
-int repo_resolve_references(void)
+errno_t repo_resolve_references(void)
 {
 	sysman_log(LVL_DEBUG2, "%s", __func__);
Index: uspace/srv/sysman/repo.h
===================================================================
--- uspace/srv/sysman/repo.h	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/repo.h	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -64,6 +64,6 @@
 extern void repo_init(void);
 
-extern int repo_add_unit(unit_t *);
-extern int repo_remove_unit(unit_t *);
+extern errno_t repo_add_unit(unit_t *);
+extern errno_t repo_remove_unit(unit_t *);
 
 extern void repo_begin_update(void);
@@ -73,5 +73,5 @@
 extern void repo_rollback(void);
 
-extern int repo_resolve_references(void);
+extern errno_t repo_resolve_references(void);
 
 extern unit_t *repo_find_unit_by_name(const char *);
Index: uspace/srv/sysman/sm_task.c
===================================================================
--- uspace/srv/sysman/sm_task.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/sm_task.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -88,5 +88,5 @@
 	unit_t *u_svc = unit_create(UNIT_SERVICE);
 	bool in_repo_update = false;
-	int rc = EOK;
+	errno_t rc = EOK;
 
 	if (u_svc == NULL) {
@@ -139,5 +139,5 @@
 {
 	repo_begin_update();
-	int rc = repo_remove_unit(&u_svc->unit);
+	errno_t rc = repo_remove_unit(&u_svc->unit);
 	if (rc != EOK) {
 		sysman_log(LVL_WARN, "Can't remove unit %s (%i).",
Index: uspace/srv/sysman/sysman.c
===================================================================
--- uspace/srv/sysman/sysman.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/sysman.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -375,5 +375,5 @@
 	free(job_args);
 
-	int rc = job_create_closure(job, &job_closure, flags);
+	errno_t rc = job_create_closure(job, &job_closure, flags);
 	if (rc != EOK) {
 		sysman_log(LVL_ERROR, "Cannot create closure for job %p (%i)",
Index: uspace/srv/sysman/test/job_closure.c
===================================================================
--- uspace/srv/sysman/test/job_closure.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/test/job_closure.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -114,5 +114,5 @@
 
 	dyn_array_initialize(&exp_closure, job_t *);
-	int rc = dyn_array_reserve(&exp_closure, MAX_TYPES * MAX_UNITS);
+	errno_t rc = dyn_array_reserve(&exp_closure, MAX_TYPES * MAX_UNITS);
 	assert(rc == EOK);
 
@@ -153,5 +153,5 @@
 	assert(main_job);
 
-	int rc = job_create_closure(main_job, &act_closure, 0);
+	errno_t rc = job_create_closure(main_job, &act_closure, 0);
 	PCUT_ASSERT_INT_EQUALS(EOK, rc);
 
@@ -185,5 +185,5 @@
 	assert(main_job);
 
-	int rc = job_create_closure(main_job, &act_closure, 0);
+	errno_t rc = job_create_closure(main_job, &act_closure, 0);
 	PCUT_ASSERT_INT_EQUALS(EOK, rc);
 
@@ -219,5 +219,5 @@
 	assert(main_job);
 
-	int rc = job_create_closure(main_job, &act_closure, 0);
+	errno_t rc = job_create_closure(main_job, &act_closure, 0);
 	PCUT_ASSERT_INT_EQUALS(EOK, rc);
 
@@ -266,5 +266,5 @@
 	assert(main_job);
 
-	int rc = job_create_closure(main_job, &act_closure, CLOSURE_ISOLATE);
+	errno_t rc = job_create_closure(main_job, &act_closure, CLOSURE_ISOLATE);
 	PCUT_ASSERT_INT_EQUALS(EOK, rc);
 
Index: uspace/srv/sysman/test/job_queue.c
===================================================================
--- uspace/srv/sysman/test/job_queue.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/test/job_queue.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -86,5 +86,5 @@
 	job_t *job = NULL;
 
-	int rc = sysman_run_job(u, STATE_STARTED, 0, &job_finished_cb,
+	errno_t rc = sysman_run_job(u, STATE_STARTED, 0, &job_finished_cb,
 	    &job);
 	PCUT_ASSERT_INT_EQUALS(EOK, rc);
@@ -106,5 +106,5 @@
 	job_t *job = NULL;
 
-	int rc = sysman_run_job(u, STATE_STARTED, 0, &job_finished_cb, &job);
+	errno_t rc = sysman_run_job(u, STATE_STARTED, 0, &job_finished_cb, &job);
 	PCUT_ASSERT_INT_EQUALS(EOK, rc);
 
@@ -147,5 +147,5 @@
 	/* Run test */
 	job_t *job = NULL;
-	int rc = sysman_run_job(s1, STATE_STARTED, 0, &job_finished_cb, &job);
+	errno_t rc = sysman_run_job(s1, STATE_STARTED, 0, &job_finished_cb, &job);
 	PCUT_ASSERT_INT_EQUALS(EOK, rc);
 
@@ -169,5 +169,5 @@
 	/* Create and start first job */
 	job_t *j0 = NULL;
-	int rc = sysman_run_job(s0, STATE_STARTED, 0, &job_finished_cb, &j0);
+	errno_t rc = sysman_run_job(s0, STATE_STARTED, 0, &job_finished_cb, &j0);
 	PCUT_ASSERT_INT_EQUALS(EOK, rc);
 
Index: uspace/srv/sysman/test/mock_unit.c
===================================================================
--- uspace/srv/sysman/test/mock_unit.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/test/mock_unit.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -78,5 +78,5 @@
 void mock_add_edge(unit_t *input, unit_t *output)
 {
-	int rc = edge_connect(input, output);
+	errno_t rc = edge_connect(input, output);
 	assert(rc == EOK);
 
@@ -87,5 +87,5 @@
 }
 
-int mock_unit_vmt_start_sync(unit_t *unit)
+errno_t mock_unit_vmt_start_sync(unit_t *unit)
 {
 	unit->state = STATE_STARTED;
@@ -93,5 +93,5 @@
 }
 
-int mock_unit_vmt_start_async(unit_t *unit)
+errno_t mock_unit_vmt_start_async(unit_t *unit)
 {
 	unit->state = STATE_STARTING;
Index: uspace/srv/sysman/test/mock_unit.h
===================================================================
--- uspace/srv/sysman/test/mock_unit.h	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/test/mock_unit.h	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -48,6 +48,6 @@
 extern void mock_add_edge(unit_t *, unit_t *);
 
-extern int mock_unit_vmt_start_sync(unit_t *);
-extern int mock_unit_vmt_start_async(unit_t *);
+extern errno_t mock_unit_vmt_start_sync(unit_t *);
+extern errno_t mock_unit_vmt_start_async(unit_t *);
 extern void mock_unit_vmt_exposee_created(unit_t *);
 
Index: uspace/srv/sysman/unit.c
===================================================================
--- uspace/srv/sysman/unit.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/unit.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -105,10 +105,10 @@
 }
 
-int unit_load(unit_t *unit, ini_configuration_t *ini_conf,
+errno_t unit_load(unit_t *unit, ini_configuration_t *ini_conf,
     text_parse_t *text_parse)
 {
 	sysman_log(LVL_DEBUG, "%s('%s')", __func__, unit_name(unit));
 
-	int rc = EOK;
+	errno_t rc = EOK;
 	ini_section_t *unit_section = ini_get_section(ini_conf, section_name);
 	if (unit_section) {
@@ -135,5 +135,5 @@
  *   - STATE_FAILED.  (unit state changed and error occured)
  */
-int unit_start(unit_t *unit)
+errno_t unit_start(unit_t *unit)
 {
 	sysman_log(LVL_NOTE, "%s('%s')", __func__, unit_name(unit));
@@ -145,5 +145,5 @@
  * Same semantics like for unit_start applies.
  */
-int unit_stop(unit_t *unit)
+errno_t unit_stop(unit_t *unit)
 {
 	sysman_log(LVL_NOTE, "%s('%s')", __func__, unit_name(unit));
Index: uspace/srv/sysman/unit.h
===================================================================
--- uspace/srv/sysman/unit.h	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/unit.h	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -120,9 +120,9 @@
 	void (*destroy)(unit_t *);
 
-	int (*load)(unit_t *, ini_configuration_t *, text_parse_t *);
+	errno_t (*load)(unit_t *, ini_configuration_t *, text_parse_t *);
 
-	int (*start)(unit_t *);
+	errno_t (*start)(unit_t *);
 
-	int (*stop)(unit_t *);
+	errno_t (*stop)(unit_t *);
 
 	void (*exposee_created)(unit_t *);
@@ -150,7 +150,7 @@
 extern void unit_destroy(unit_t **);
 
-extern int unit_load(unit_t *, ini_configuration_t *, text_parse_t *);
-extern int unit_start(unit_t *);
-extern int unit_stop(unit_t *);
+extern errno_t unit_load(unit_t *, ini_configuration_t *, text_parse_t *);
+extern errno_t unit_start(unit_t *);
+extern errno_t unit_stop(unit_t *);
 extern void unit_exposee_created(unit_t *);
 extern void unit_fail(unit_t *);
Index: uspace/srv/sysman/units/unit_tgt.c
===================================================================
--- uspace/srv/sysman/units/unit_tgt.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/sysman/units/unit_tgt.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -45,5 +45,5 @@
 }
 
-static int unit_tgt_load(unit_t *unit, ini_configuration_t *ini_conf,
+static errno_t unit_tgt_load(unit_t *unit, ini_configuration_t *ini_conf,
     text_parse_t *text_parse)
 {
@@ -54,5 +54,5 @@
 }
 
-static int unit_tgt_start(unit_t *unit)
+static errno_t unit_tgt_start(unit_t *unit)
 {
 	unit_tgt_t *u_tgt = CAST_TGT(unit);
@@ -63,5 +63,5 @@
 }
 
-static int unit_tgt_stop(unit_t *unit)
+static errno_t unit_tgt_stop(unit_t *unit)
 {
 	unit_tgt_t *u_tgt = CAST_TGT(unit);
Index: uspace/srv/taskman/task.c
===================================================================
--- uspace/srv/taskman/task.c	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/taskman/task.c	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -119,5 +119,5 @@
 }
 
-int tasks_init(void)
+errno_t tasks_init(void)
 {
 	if (!hash_table_create(&task_hash_table, 0, 0, &task_hash_table_ops)) {
@@ -191,7 +191,7 @@
 }
 
-int task_intro(task_id_t id)
-{
-	int rc = EOK;
+errno_t task_intro(task_id_t id)
+{
+	errno_t rc = EOK;
 
 	fibril_rwlock_write_lock(&task_hash_table_lock);
Index: uspace/srv/taskman/task.h
===================================================================
--- uspace/srv/taskman/task.h	(revision 102f64118e58e5b4f4c5b0001b105be87f38d435)
+++ uspace/srv/taskman/task.h	(revision 25697163af08e9c7749aee9f2aa974ed6ffb46ef)
@@ -77,5 +77,5 @@
 extern fibril_rwlock_t task_hash_table_lock;
 
-extern int tasks_init(void);
+extern errno_t tasks_init(void);
 
 extern task_t *task_get_by_id(task_id_t);
@@ -85,5 +85,5 @@
 extern void task_remove(task_t **);
 
-extern int task_intro(task_id_t);
+extern errno_t task_intro(task_id_t);
 
 #endif