Index: uspace/lib/c/generic/async/client.c
===================================================================
--- uspace/lib/c/generic/async/client.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/async/client.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -557,28 +557,34 @@
 errno_t async_req_0_0(async_exch_t *exch, sysarg_t imethod)
 {
-	return async_req_fast(exch, imethod, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
+	return async_req_fast(exch, imethod, 0, 0, 0, 0, NULL, NULL, NULL, NULL,
+	    NULL);
 }
 
 errno_t async_req_0_1(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1)
 {
-	return async_req_fast(exch, imethod, 0, 0, 0, 0, r1, NULL, NULL, NULL, NULL);
-}
-
-errno_t async_req_0_2(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1, sysarg_t *r2)
+	return async_req_fast(exch, imethod, 0, 0, 0, 0, r1, NULL, NULL, NULL,
+	    NULL);
+}
+
+errno_t async_req_0_2(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1,
+    sysarg_t *r2)
 {
 	return async_req_fast(exch, imethod, 0, 0, 0, 0, r1, r2, NULL, NULL, NULL);
 }
 
-errno_t async_req_0_3(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
+errno_t async_req_0_3(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1,
+    sysarg_t *r2, sysarg_t *r3)
 {
 	return async_req_fast(exch, imethod, 0, 0, 0, 0, r1, r2, r3, NULL, NULL);
 }
 
-errno_t async_req_0_4(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
+errno_t async_req_0_4(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1,
+    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
 {
 	return async_req_fast(exch, imethod, 0, 0, 0, 0, r1, r2, r3, r4, NULL);
 }
 
-errno_t async_req_0_5(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
+errno_t async_req_0_5(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1,
+    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
 {
 	return async_req_fast(exch, imethod, 0, 0, 0, 0, r1, r2, r3, r4, r5);
@@ -587,150 +593,215 @@
 errno_t async_req_1_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1)
 {
-	return async_req_fast(exch, imethod, arg1, 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
-}
-
-errno_t async_req_1_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t *r1)
-{
-	return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, NULL, NULL, NULL, NULL);
-}
-
-errno_t async_req_1_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t *r1, sysarg_t *r2)
-{
-	return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, r2, NULL, NULL, NULL);
-}
-
-errno_t async_req_1_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
-{
-	return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, r2, r3, NULL, NULL);
-}
-
-errno_t async_req_1_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
+	return async_req_fast(exch, imethod, arg1, 0, 0, 0, NULL, NULL, NULL, NULL,
+	    NULL);
+}
+
+errno_t async_req_1_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t *r1)
+{
+	return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, NULL, NULL, NULL,
+	    NULL);
+}
+
+errno_t async_req_1_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t *r1, sysarg_t *r2)
+{
+	return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, r2, NULL, NULL,
+	    NULL);
+}
+
+errno_t async_req_1_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
+{
+	return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, r2, r3, NULL,
+	    NULL);
+}
+
+errno_t async_req_1_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
 {
 	return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, r2, r3, r4, NULL);
 }
 
-errno_t async_req_1_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
+errno_t async_req_1_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
 {
 	return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, r2, r3, r4, r5);
 }
 
-errno_t async_req_2_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, 0, 0, NULL, NULL, NULL, NULL, NULL);
-}
-
-errno_t async_req_2_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t *r1)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, NULL, NULL, NULL, NULL);
-}
-
-errno_t async_req_2_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t *r1, sysarg_t *r2)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, NULL, NULL, NULL);
-}
-
-errno_t async_req_2_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, r3, NULL, NULL);
-}
-
-errno_t async_req_2_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, r3, r4, NULL);
-}
-
-errno_t async_req_2_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
+errno_t async_req_2_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, 0, 0, NULL, NULL, NULL,
+	    NULL, NULL);
+}
+
+errno_t async_req_2_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t *r1)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, NULL, NULL,
+	    NULL, NULL);
+}
+
+errno_t async_req_2_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t *r1, sysarg_t *r2)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, NULL,
+	    NULL, NULL);
+}
+
+errno_t async_req_2_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, r3, NULL,
+	    NULL);
+}
+
+errno_t async_req_2_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, r3, r4,
+	    NULL);
+}
+
+errno_t async_req_2_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
 {
 	return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, r3, r4, r5);
 }
 
-errno_t async_req_3_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, NULL, NULL, NULL, NULL, NULL);
-}
-
-errno_t async_req_3_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t *r1)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, NULL, NULL, NULL, NULL);
-}
-
-errno_t async_req_3_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, NULL, NULL, NULL);
-}
-
-errno_t async_req_3_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, r3, NULL, NULL);
-}
-
-errno_t async_req_3_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, r3, r4, NULL);
-}
-
-errno_t async_req_3_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, r3, r4, r5);
-}
-
-errno_t async_req_4_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, NULL, NULL, NULL, NULL, NULL);
-}
-
-errno_t async_req_4_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, NULL, NULL, NULL, NULL);
-}
-
-errno_t async_req_4_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, NULL, NULL, NULL);
-}
-
-errno_t async_req_4_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, r3, NULL, NULL);
-}
-
-errno_t async_req_4_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, r3, r4, NULL);
-}
-
-errno_t async_req_4_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
-{
-	return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, r3, r4, r5);
-}
-
-errno_t async_req_5_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
-{
-	return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, NULL, NULL, NULL, NULL, NULL);
-}
-
-errno_t async_req_5_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1)
-{
-	return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, NULL, NULL, NULL, NULL);
-}
-
-errno_t async_req_5_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1, sysarg_t *r2)
-{
-	return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2, NULL, NULL, NULL);
-}
-
-errno_t async_req_5_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
-{
-	return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2, r3, NULL, NULL);
-}
-
-errno_t async_req_5_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
-{
-	return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2, r3, r4, NULL);
-}
-
-errno_t async_req_5_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
-{
-	return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2, r3, r4, r5);
+errno_t async_req_3_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, NULL, NULL, NULL,
+	    NULL, NULL);
+}
+
+errno_t async_req_3_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t *r1)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, NULL, NULL,
+	    NULL, NULL);
+}
+
+errno_t async_req_3_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, NULL,
+	    NULL, NULL);
+}
+
+errno_t async_req_3_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, r3, NULL,
+	    NULL);
+}
+
+errno_t async_req_3_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3,
+    sysarg_t *r4)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, r3, r4,
+	    NULL);
+}
+
+errno_t async_req_3_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3,
+    sysarg_t *r4, sysarg_t *r5)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, r3, r4,
+	    r5);
+}
+
+errno_t async_req_4_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, NULL, NULL,
+	    NULL, NULL, NULL);
+}
+
+errno_t async_req_4_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, NULL,
+	    NULL, NULL, NULL);
+}
+
+errno_t async_req_4_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, NULL,
+	    NULL, NULL);
+}
+
+errno_t async_req_4_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
+    sysarg_t *r3)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, r3,
+	    NULL, NULL);
+}
+
+errno_t async_req_4_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
+    sysarg_t *r3, sysarg_t *r4)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, r3,
+	    r4, NULL);
+}
+
+errno_t async_req_4_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
+    sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
+{
+	return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, r3,
+	    r4, r5);
+}
+
+errno_t async_req_5_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
+{
+	return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, NULL,
+	    NULL, NULL, NULL, NULL);
+}
+
+errno_t async_req_5_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1)
+{
+	return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1,
+	    NULL, NULL, NULL, NULL);
+}
+
+errno_t async_req_5_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
+    sysarg_t *r2)
+{
+	return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2,
+	    NULL, NULL, NULL);
+}
+
+errno_t async_req_5_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
+    sysarg_t *r2, sysarg_t *r3)
+{
+	return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2,
+	    r3, NULL, NULL);
+}
+
+errno_t async_req_5_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
+    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
+{
+	return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2,
+	    r3, r4, NULL);
+}
+
+errno_t async_req_5_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
+    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
+{
+	return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2,
+	    r3, r4, r5);
 }
 
@@ -818,4 +889,5 @@
  * @param arg2  User defined argument.
  * @param arg3  User defined argument.
+ * @param rc    Placeholder for return code. Unused if NULL.
  *
  * @return New session on success or NULL on error.
@@ -823,8 +895,10 @@
  */
 async_sess_t *async_connect_me_to(async_exch_t *exch, iface_t iface,
-    sysarg_t arg2, sysarg_t arg3)
+    sysarg_t arg2, sysarg_t arg3, errno_t *rc)
 {
 	if (exch == NULL) {
-		errno = ENOENT;
+		if (rc != NULL)
+			*rc = ENOENT;
+
 		return NULL;
 	}
@@ -832,13 +906,17 @@
 	async_sess_t *sess = calloc(1, sizeof(async_sess_t));
 	if (sess == NULL) {
-		errno = ENOMEM;
+		if (rc != NULL)
+			*rc = ENOMEM;
+
 		return NULL;
 	}
 
 	cap_phone_handle_t phone;
-	errno_t rc = async_connect_me_to_internal(exch->phone, iface, arg2,
+	errno_t ret = async_connect_me_to_internal(exch->phone, iface, arg2,
 	    arg3, 0, &phone);
-	if (rc != EOK) {
-		errno = rc;
+	if (ret != EOK) {
+		if (rc != NULL)
+			*rc = ret;
+
 		free(sess);
 		return NULL;
@@ -886,4 +964,5 @@
  * @param arg2  User defined argument.
  * @param arg3  User defined argument.
+ * @param rc    Placeholder for return code. Unused if NULL.
  *
  * @return New session on success or NULL on error.
@@ -891,8 +970,10 @@
  */
 async_sess_t *async_connect_me_to_blocking(async_exch_t *exch, iface_t iface,
-    sysarg_t arg2, sysarg_t arg3)
+    sysarg_t arg2, sysarg_t arg3, errno_t *rc)
 {
 	if (exch == NULL) {
-		errno = ENOENT;
+		if (rc != NULL)
+			*rc = ENOENT;
+
 		return NULL;
 	}
@@ -900,13 +981,17 @@
 	async_sess_t *sess = calloc(1, sizeof(async_sess_t));
 	if (sess == NULL) {
-		errno = ENOMEM;
+		if (rc != NULL)
+			*rc = ENOMEM;
+
 		return NULL;
 	}
 
 	cap_phone_handle_t phone;
-	errno_t rc = async_connect_me_to_internal(exch->phone, iface, arg2,
+	errno_t ret = async_connect_me_to_internal(exch->phone, iface, arg2,
 	    arg3, IPC_FLAG_BLOCKING, &phone);
-	if (rc != EOK) {
-		errno = rc;
+	if (ret != EOK) {
+		if (rc != NULL)
+			*rc = ret;
+
 		free(sess);
 		return NULL;
@@ -928,17 +1013,26 @@
 /** Connect to a task specified by id.
  *
- */
-async_sess_t *async_connect_kbox(task_id_t id)
+ * @param id Task to which to connect.
+ * @param rc Placeholder for return code. Unused if NULL.
+ *
+ * @return New session on success or NULL on error.
+ *
+ */
+async_sess_t *async_connect_kbox(task_id_t id, errno_t *rc)
 {
 	async_sess_t *sess = calloc(1, sizeof(async_sess_t));
 	if (sess == NULL) {
-		errno = ENOMEM;
+		if (rc != NULL)
+			*rc = ENOMEM;
+
 		return NULL;
 	}
 
 	cap_phone_handle_t phone;
-	errno_t rc = ipc_connect_kbox(id, &phone);
-	if (rc != EOK) {
-		errno = rc;
+	errno_t ret = ipc_connect_kbox(id, &phone);
+	if (ret != EOK) {
+		if (rc != NULL)
+			*rc = ret;
+
 		free(sess);
 		return NULL;
@@ -956,7 +1050,11 @@
 }
 
-static errno_t async_hangup_internal(cap_phone_handle_t phone)
-{
-	return ipc_hangup(phone);
+static void async_hangup_internal(cap_phone_handle_t phone)
+{
+	errno_t rc;
+
+	rc = ipc_hangup(phone);
+	assert(rc == EOK);
+	(void) rc;
 }
 
@@ -964,9 +1062,6 @@
  *
  * @param sess Session to hung up.
- *
- * @return Zero on success or an error code.
- *
- */
-errno_t async_hangup(async_sess_t *sess)
+ */
+void async_hangup(async_sess_t *sess)
 {
 	async_exch_t *exch;
@@ -975,11 +1070,7 @@
 
 	fibril_mutex_lock(&async_sess_mutex);
-
-	if (sess->exchanges > 0) {
-		fibril_mutex_unlock(&async_sess_mutex);
-		return EBUSY;
-	}
-
-	errno_t rc = async_hangup_internal(sess->phone);
+	assert(sess->exchanges == 0);
+
+	async_hangup_internal(sess->phone);
 
 	while (!list_empty(&sess->exch_list)) {
@@ -990,5 +1081,7 @@
 		list_remove(&exch->sess_link);
 		list_remove(&exch->global_link);
-		async_hangup_internal(exch->phone);
+		if (sess->mgmt != EXCHANGE_ATOMIC &&
+		    sess->mgmt != EXCHANGE_SERIALIZE)
+			async_hangup_internal(exch->phone);
 		free(exch);
 	}
@@ -997,6 +1090,4 @@
 
 	fibril_mutex_unlock(&async_sess_mutex);
-
-	return rc;
 }
 
Index: uspace/lib/c/generic/devman.c
===================================================================
--- uspace/lib/c/generic/devman.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/devman.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -89,5 +89,5 @@
 				devman_driver_block_sess =
 				    service_connect_blocking(SERVICE_DEVMAN,
-				    INTERFACE_DDF_DRIVER, 0);
+				    INTERFACE_DDF_DRIVER, 0, NULL);
 		}
 
@@ -108,5 +108,5 @@
 				devman_client_block_sess =
 				    service_connect_blocking(SERVICE_DEVMAN,
-				    INTERFACE_DDF_CLIENT, 0);
+				    INTERFACE_DDF_CLIENT, 0, NULL);
 		}
 
@@ -138,5 +138,5 @@
 			devman_driver_sess =
 			    service_connect(SERVICE_DEVMAN,
-			    INTERFACE_DDF_DRIVER, 0);
+			    INTERFACE_DDF_DRIVER, 0, NULL);
 
 		fibril_mutex_unlock(&devman_driver_mutex);
@@ -152,5 +152,5 @@
 			devman_client_sess =
 			    service_connect(SERVICE_DEVMAN,
-			    INTERFACE_DDF_CLIENT, 0);
+			    INTERFACE_DDF_CLIENT, 0, NULL);
 
 		fibril_mutex_unlock(&devman_client_mutex);
@@ -292,8 +292,8 @@
 	if (flags & IPC_FLAG_BLOCKING)
 		sess = service_connect_blocking(SERVICE_DEVMAN,
-		    INTERFACE_DEVMAN_DEVICE, handle);
+		    INTERFACE_DEVMAN_DEVICE, handle, NULL);
 	else
 		sess = service_connect(SERVICE_DEVMAN,
-		    INTERFACE_DEVMAN_DEVICE, handle);
+		    INTERFACE_DEVMAN_DEVICE, handle, NULL);
 
 	return sess;
@@ -350,8 +350,8 @@
 	if (flags & IPC_FLAG_BLOCKING)
 		sess = service_connect_blocking(SERVICE_DEVMAN,
-		    INTERFACE_DEVMAN_PARENT, handle);
+		    INTERFACE_DEVMAN_PARENT, handle, NULL);
 	else
-		sess = service_connect_blocking(SERVICE_DEVMAN,
-		    INTERFACE_DEVMAN_PARENT, handle);
+		sess = service_connect(SERVICE_DEVMAN,
+		    INTERFACE_DEVMAN_PARENT, handle, NULL);
 
 	return sess;
Index: uspace/lib/c/generic/inet/tcp.c
===================================================================
--- uspace/lib/c/generic/inet/tcp.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/inet/tcp.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -455,12 +455,11 @@
 	exch = async_exchange_begin(conn->tcp->sess);
 	aid_t req = async_send_1(exch, TCP_CONN_SEND, conn->id, NULL);
-
 	rc = async_data_write_start(exch, data, bytes);
+	async_exchange_end(exch);
+
 	if (rc != EOK) {
 		async_forget(req);
 		return rc;
 	}
-
-	async_exchange_end(exch);
 
 	if (rc != EOK) {
Index: uspace/lib/c/generic/inetcfg.c
===================================================================
--- uspace/lib/c/generic/inetcfg.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/inetcfg.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -103,7 +103,10 @@
 
 		alloc_size = act_size;
-		ids = realloc(ids, alloc_size);
-		if (ids == NULL)
+		service_id_t *tmp = realloc(ids, alloc_size);
+		if (tmp == NULL) {
+			free(ids);
 			return ENOMEM;
+		}
+		ids = tmp;
 	}
 
Index: uspace/lib/c/generic/io/asprintf.c
===================================================================
--- uspace/lib/c/generic/io/asprintf.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/io/asprintf.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -46,5 +46,5 @@
 }
 
-static int asprintf_wstr_write(const wchar_t *str, size_t count, void *unused)
+static int asprintf_wstr_write(const char32_t *str, size_t count, void *unused)
 {
 	return wstr_nlength(str, count);
Index: uspace/lib/c/generic/io/chargrid.c
===================================================================
--- uspace/lib/c/generic/io/chargrid.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/io/chargrid.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -140,5 +140,5 @@
  *
  */
-sysarg_t chargrid_putwchar(chargrid_t *scrbuf, wchar_t ch, bool update)
+sysarg_t chargrid_putuchar(chargrid_t *scrbuf, char32_t ch, bool update)
 {
 	assert(scrbuf->col < scrbuf->cols);
@@ -199,5 +199,5 @@
 
 	for (sysarg_t i = 0; i < spaces; i++)
-		flush += chargrid_putwchar(scrbuf, ' ', true) - 1;
+		flush += chargrid_putuchar(scrbuf, ' ', true) - 1;
 
 	return flush;
@@ -228,10 +228,10 @@
 		scrbuf->row--;
 
-		chargrid_putwchar(scrbuf, ' ', false);
+		chargrid_putuchar(scrbuf, ' ', false);
 		return 2;
 	}
 
 	scrbuf->col--;
-	chargrid_putwchar(scrbuf, ' ', false);
+	chargrid_putuchar(scrbuf, ' ', false);
 	return 1;
 }
Index: uspace/lib/c/generic/io/input.c
===================================================================
--- uspace/lib/c/generic/io/input.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/io/input.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -109,5 +109,5 @@
 	keycode_t key;
 	keymod_t mods;
-	wchar_t c;
+	char32_t c;
 	errno_t rc;
 
Index: uspace/lib/c/generic/io/io.c
===================================================================
--- uspace/lib/c/generic/io/io.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/io/io.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -48,4 +48,5 @@
 #include <adt/list.h>
 #include <wchar.h>
+#include <uchar.h>
 #include "../private/io.h"
 #include "../private/stdio.h"
@@ -749,7 +750,29 @@
 }
 
+wint_t fputuc(char32_t wc, FILE *stream)
+{
+	char buf[STR_BOUNDS(1)];
+	size_t sz = 0;
+
+	if (chr_encode(wc, buf, &sz, STR_BOUNDS(1)) != EOK) {
+		errno = EILSEQ;
+		return WEOF;
+	}
+
+	size_t wr = fwrite(buf, 1, sz, stream);
+	if (wr < sz)
+		return WEOF;
+
+	return wc;
+}
+
 wint_t putwchar(wchar_t wc)
 {
 	return fputwc(wc, stdout);
+}
+
+wint_t putuchar(char32_t wc)
+{
+	return fputuc(wc, stdout);
 }
 
Index: uspace/lib/c/generic/io/kio.c
===================================================================
--- uspace/lib/c/generic/io/kio.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/io/kio.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -140,5 +140,5 @@
 }
 
-static int kio_vprintf_wstr_write(const wchar_t *str, size_t size, void *data)
+static int kio_vprintf_wstr_write(const char32_t *str, size_t size, void *data)
 {
 	size_t offset = 0;
@@ -154,5 +154,5 @@
 
 		chars++;
-		offset += sizeof(wchar_t);
+		offset += sizeof(char32_t);
 	}
 
Index: uspace/lib/c/generic/io/log.c
===================================================================
--- uspace/lib/c/generic/io/log.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/io/log.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -167,9 +167,9 @@
 		return ENOMEM;
 
+	errno_t rc;
 	logger_session = service_connect_blocking(SERVICE_LOGGER,
-	    INTERFACE_LOGGER_WRITER, 0);
-	if (logger_session == NULL) {
-		return ENOMEM;
-	}
+	    INTERFACE_LOGGER_WRITER, 0, &rc);
+	if (logger_session == NULL)
+		return rc;
 
 	default_log_id = log_create(prog_name, LOG_NO_PARENT);
Index: uspace/lib/c/generic/io/logctl.c
===================================================================
--- uspace/lib/c/generic/io/logctl.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/io/logctl.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -48,8 +48,9 @@
 
 	if (logger_session == NULL) {
+		errno_t rc;
 		logger_session = service_connect_blocking(SERVICE_LOGGER,
-		    INTERFACE_LOGGER_CONTROL, 0);
+		    INTERFACE_LOGGER_CONTROL, 0, &rc);
 		if (logger_session == NULL)
-			return ENOMEM;
+			return rc;
 	}
 
Index: uspace/lib/c/generic/io/printf_core.c
===================================================================
--- uspace/lib/c/generic/io/printf_core.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/io/printf_core.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -47,5 +47,5 @@
 #include <assert.h>
 #include <macros.h>
-#include <wchar.h>
+#include <uchar.h>
 
 /** show prefixes 0x or 0 */
@@ -187,5 +187,5 @@
  *
  */
-static int printf_wputnchars(const wchar_t *buf, size_t size,
+static int printf_wputnchars(const char32_t *buf, size_t size,
     printf_spec_t *ps)
 {
@@ -233,10 +233,10 @@
  *
  */
-static int printf_putwchar(const wchar_t ch, printf_spec_t *ps)
+static int printf_putuchar(const char32_t ch, printf_spec_t *ps)
 {
 	if (!chr_check(ch))
 		return ps->str_write((void *) &invalch, 1, ps->data);
 
-	return ps->wstr_write(&ch, sizeof(wchar_t), ps->data);
+	return ps->wstr_write(&ch, sizeof(char32_t), ps->data);
 }
 
@@ -288,5 +288,5 @@
  *
  */
-static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)
+static int print_wchar(const char32_t ch, int width, uint32_t flags, printf_spec_t *ps)
 {
 	size_t counter = 0;
@@ -302,5 +302,5 @@
 	}
 
-	if (printf_putwchar(ch, ps) > 0)
+	if (printf_putuchar(ch, ps) > 0)
 		counter++;
 
@@ -375,5 +375,5 @@
  * @return Number of wide characters printed, negative value on failure.
  */
-static int print_wstr(wchar_t *str, int width, unsigned int precision,
+static int print_wstr(char32_t *str, int width, unsigned int precision,
     uint32_t flags, printf_spec_t *ps)
 {
@@ -1276,5 +1276,5 @@
  *  - "l"  Signed or unsigned long int.@n
  *         If conversion is "c", the character is wint_t (wide character).@n
- *         If conversion is "s", the string is wchar_t * (wide string).@n
+ *         If conversion is "s", the string is char32_t * (wide string).@n
  *  - "ll" Signed or unsigned long long int.@n
  *  - "z"  Signed or unsigned ssize_t or site_t.@n
@@ -1330,5 +1330,5 @@
 	while (true) {
 		i = nxt;
-		wchar_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
+		char32_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
 
 		if (uc == 0)
@@ -1493,5 +1493,5 @@
 
 				if (qualifier == PrintfQualifierLong)
-					retval = print_wstr(va_arg(ap, wchar_t *), width, precision, flags, ps);
+					retval = print_wstr(va_arg(ap, char32_t *), width, precision, flags, ps);
 				else
 					retval = print_str(va_arg(ap, char *), width, precision, flags, ps);
Index: uspace/lib/c/generic/io/vprintf.c
===================================================================
--- uspace/lib/c/generic/io/vprintf.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/io/vprintf.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -48,5 +48,5 @@
 }
 
-static int vprintf_wstr_write(const wchar_t *str, size_t size, void *stream)
+static int vprintf_wstr_write(const char32_t *str, size_t size, void *stream)
 {
 	size_t offset = 0;
@@ -54,9 +54,9 @@
 
 	while (offset < size) {
-		if (fputwc(str[chars], (FILE *) stream) <= 0)
+		if (fputuc(str[chars], (FILE *) stream) <= 0)
 			break;
 
 		chars++;
-		offset += sizeof(wchar_t);
+		offset += sizeof(char32_t);
 	}
 
Index: uspace/lib/c/generic/io/vsnprintf.c
===================================================================
--- uspace/lib/c/generic/io/vsnprintf.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/io/vsnprintf.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -88,5 +88,5 @@
 
 		while (index < size) {
-			wchar_t uc = str_decode(str, &index, size);
+			char32_t uc = str_decode(str, &index, size);
 
 			if (chr_encode(uc, data->dst, &data->len, data->size - 1) != EOK)
@@ -133,9 +133,9 @@
  *
  */
-static int vsnprintf_wstr_write(const wchar_t *str, size_t size, vsnprintf_data_t *data)
+static int vsnprintf_wstr_write(const char32_t *str, size_t size, vsnprintf_data_t *data)
 {
 	size_t index = 0;
 
-	while (index < (size / sizeof(wchar_t))) {
+	while (index < (size / sizeof(char32_t))) {
 		size_t left = data->size - data->len;
 
@@ -177,5 +177,5 @@
 	printf_spec_t ps = {
 		(int (*) (const char *, size_t, void *)) vsnprintf_str_write,
-		(int (*) (const wchar_t *, size_t, void *)) vsnprintf_wstr_write,
+		(int (*) (const char32_t *, size_t, void *)) vsnprintf_wstr_write,
 		&data
 	};
Index: uspace/lib/c/generic/loader.c
===================================================================
--- uspace/lib/c/generic/loader.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/loader.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -46,11 +46,13 @@
 #include "private/loader.h"
 
-/** Connect to a new program loader.
- *
- * Spawns a new program loader task and returns the connection structure.
+/** Spawn a new program loader.
+ *
+ * Spawn a new program loader task. The loader then independetly
+ * connects to the naming service.
  *
  * @param name Symbolic name to set on the newly created task.
  *
  * @return Error code.
+ *
  */
 errno_t loader_spawn(const char *name)
@@ -60,5 +62,12 @@
 }
 
-loader_t *loader_connect(void)
+/** Connect to a program loader.
+ *
+ * @param rc Placeholder for return code. Unused if NULL.
+ *
+ * @return Loader structure.
+ *
+ */
+loader_t *loader_connect(errno_t *rc)
 {
 	loader_t *ldr = malloc(sizeof(loader_t));
@@ -67,5 +76,5 @@
 
 	async_sess_t *sess =
-	    service_connect_blocking(SERVICE_LOADER, INTERFACE_LOADER, 0);
+	    service_connect_blocking(SERVICE_LOADER, INTERFACE_LOADER, 0, rc);
 	if (sess == NULL) {
 		free(ldr);
Index: uspace/lib/c/generic/loc.c
===================================================================
--- uspace/lib/c/generic/loc.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/loc.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -153,5 +153,5 @@
 				loc_supp_block_sess =
 				    service_connect_blocking(SERVICE_LOC,
-				    INTERFACE_LOC_SUPPLIER, 0);
+				    INTERFACE_LOC_SUPPLIER, 0, NULL);
 		}
 
@@ -172,5 +172,5 @@
 				loc_cons_block_sess =
 				    service_connect_blocking(SERVICE_LOC,
-				    INTERFACE_LOC_CONSUMER, 0);
+				    INTERFACE_LOC_CONSUMER, 0, NULL);
 		}
 
@@ -202,5 +202,5 @@
 			loc_supplier_sess =
 			    service_connect(SERVICE_LOC,
-			    INTERFACE_LOC_SUPPLIER, 0);
+			    INTERFACE_LOC_SUPPLIER, 0, NULL);
 
 		fibril_mutex_unlock(&loc_supplier_mutex);
@@ -216,5 +216,5 @@
 			loc_consumer_sess =
 			    service_connect(SERVICE_LOC,
-			    INTERFACE_LOC_CONSUMER, 0);
+			    INTERFACE_LOC_CONSUMER, 0, NULL);
 
 		fibril_mutex_unlock(&loc_consumer_mutex);
@@ -567,7 +567,7 @@
 
 	if (flags & IPC_FLAG_BLOCKING)
-		sess = service_connect_blocking(SERVICE_LOC, iface, handle);
+		sess = service_connect_blocking(SERVICE_LOC, iface, handle, NULL);
 	else
-		sess = service_connect(SERVICE_LOC, iface, handle);
+		sess = service_connect(SERVICE_LOC, iface, handle, NULL);
 
 	return sess;
@@ -819,7 +819,10 @@
 
 		alloc_size = act_size;
-		ids = realloc(ids, alloc_size);
-		if (ids == NULL)
+		service_id_t *tmp = realloc(ids, alloc_size);
+		if (tmp == NULL) {
+			free(ids);
 			return ENOMEM;
+		}
+		ids = tmp;
 	}
 
Index: uspace/lib/c/generic/malloc.c
===================================================================
--- uspace/lib/c/generic/malloc.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/malloc.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -35,4 +35,5 @@
 
 #include <malloc.h>
+#include <stdalign.h>
 #include <stdbool.h>
 #include <stddef.h>
@@ -81,21 +82,21 @@
 	(sizeof(heap_block_head_t) + sizeof(heap_block_foot_t))
 
+/** Calculate real size of a heap block.
+ *
+ * Add header and footer size.
+ *
+ */
+#define GROSS_SIZE(size)  ((size) + STRUCT_OVERHEAD)
+
+/** Calculate net size of a heap block.
+ *
+ * Subtract header and footer size.
+ *
+ */
+#define NET_SIZE(size)  ((size) - STRUCT_OVERHEAD)
+
 /** Overhead of each area. */
 #define AREA_OVERHEAD(size) \
-	(ALIGN_UP(size + sizeof(heap_area_t), BASE_ALIGN))
-
-/** Calculate real size of a heap block.
- *
- * Add header and footer size.
- *
- */
-#define GROSS_SIZE(size)  ((size) + STRUCT_OVERHEAD)
-
-/** Calculate net size of a heap block.
- *
- * Subtract header and footer size.
- *
- */
-#define NET_SIZE(size)  ((size) - STRUCT_OVERHEAD)
+	(ALIGN_UP(GROSS_SIZE(size) + sizeof(heap_area_t), BASE_ALIGN))
 
 /** Get first block in heap area.
@@ -198,4 +199,12 @@
 
 #define malloc_assert(expr) safe_assert(expr)
+
+/*
+ * Make sure the base alignment is sufficient.
+ */
+static_assert(BASE_ALIGN >= alignof(heap_area_t), "");
+static_assert(BASE_ALIGN >= alignof(heap_block_head_t), "");
+static_assert(BASE_ALIGN >= alignof(heap_block_foot_t), "");
+static_assert(BASE_ALIGN >= alignof(max_align_t), "");
 
 /** Serializes access to the heap from multiple threads. */
Index: uspace/lib/c/generic/ns.c
===================================================================
--- uspace/lib/c/generic/ns.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/ns.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -49,10 +49,11 @@
     async_port_handler_t handler, void *data)
 {
-	async_sess_t *sess = ns_session_get();
-	if (sess == NULL)
-		return EIO;
+	errno_t rc;
+	async_sess_t *sess = ns_session_get(&rc);
+	if (sess == NULL)
+		return rc;
 
 	port_id_t port;
-	errno_t rc = async_create_port(iface, handler, data, &port);
+	rc = async_create_port(iface, handler, data, &port);
 	if (rc != EOK)
 		return rc;
@@ -81,7 +82,8 @@
 	async_set_fallback_port_handler(handler, data);
 
-	async_sess_t *sess = ns_session_get();
-	if (sess == NULL)
-		return EIO;
+	errno_t rc;
+	async_sess_t *sess = ns_session_get(&rc);
+	if (sess == NULL)
+		return rc;
 
 	async_exch_t *exch = async_exchange_begin(sess);
@@ -89,5 +91,5 @@
 	ipc_call_t answer;
 	aid_t req = async_send_1(exch, NS_REGISTER_BROKER, service, &answer);
-	errno_t rc = async_connect_to_me(exch, INTERFACE_ANY, service, 0);
+	rc = async_connect_to_me(exch, INTERFACE_ANY, service, 0);
 
 	async_exchange_end(exch);
@@ -103,7 +105,18 @@
 }
 
-async_sess_t *service_connect(service_t service, iface_t iface, sysarg_t arg3)
-{
-	async_sess_t *sess = ns_session_get();
+/** Connect to a singleton service.
+ *
+ * @param service Singleton service ID.
+ * @param iface   Interface to connect to.
+ * @param arg3    Custom connection argument.
+ * @param rc      Placeholder for return code. Unused if NULL.
+ *
+ * @return New session on success or NULL on error.
+ *
+ */
+async_sess_t *service_connect(service_t service, iface_t iface, sysarg_t arg3,
+    errno_t *rc)
+{
+	async_sess_t *sess = ns_session_get(rc);
 	if (sess == NULL)
 		return NULL;
@@ -114,5 +127,5 @@
 
 	async_sess_t *csess =
-	    async_connect_me_to(exch, iface, service, arg3);
+	    async_connect_me_to(exch, iface, service, arg3, rc);
 	async_exchange_end(exch);
 
@@ -130,8 +143,18 @@
 }
 
+/** Wait and connect to a singleton service.
+ *
+ * @param service Singleton service ID.
+ * @param iface   Interface to connect to.
+ * @param arg3    Custom connection argument.
+ * @param rc      Placeholder for return code. Unused if NULL.
+ *
+ * @return New session on success or NULL on error.
+ *
+ */
 async_sess_t *service_connect_blocking(service_t service, iface_t iface,
-    sysarg_t arg3)
-{
-	async_sess_t *sess = ns_session_get();
+    sysarg_t arg3, errno_t *rc)
+{
+	async_sess_t *sess = ns_session_get(rc);
 	if (sess == NULL)
 		return NULL;
@@ -139,5 +162,5 @@
 	async_exch_t *exch = async_exchange_begin(sess);
 	async_sess_t *csess =
-	    async_connect_me_to_blocking(exch, iface, service, arg3);
+	    async_connect_me_to_blocking(exch, iface, service, arg3, rc);
 	async_exchange_end(exch);
 
@@ -157,30 +180,31 @@
 errno_t ns_ping(void)
 {
-	async_sess_t *sess = ns_session_get();
+	errno_t rc;
+	async_sess_t *sess = ns_session_get(&rc);
+	if (sess == NULL)
+		return rc;
+
+	async_exch_t *exch = async_exchange_begin(sess);
+	rc = async_req_0_0(exch, NS_PING);
+	async_exchange_end(exch);
+
+	return rc;
+}
+
+errno_t ns_intro(task_id_t id)
+{
+	errno_t rc;
+	async_sess_t *sess = ns_session_get(&rc);
 	if (sess == NULL)
 		return EIO;
 
 	async_exch_t *exch = async_exchange_begin(sess);
-	errno_t rc = async_req_0_0(exch, NS_PING);
-	async_exchange_end(exch);
-
-	return rc;
-}
-
-errno_t ns_intro(task_id_t id)
-{
-	async_exch_t *exch;
-	async_sess_t *sess = ns_session_get();
-	if (sess == NULL)
-		return EIO;
-
-	exch = async_exchange_begin(sess);
-	errno_t rc = async_req_2_0(exch, NS_ID_INTRO, LOWER32(id), UPPER32(id));
-	async_exchange_end(exch);
-
-	return rc;
-}
-
-async_sess_t *ns_session_get(void)
+	rc = async_req_2_0(exch, NS_ID_INTRO, LOWER32(id), UPPER32(id));
+	async_exchange_end(exch);
+
+	return rc;
+}
+
+async_sess_t *ns_session_get(errno_t *rc)
 {
 	async_exch_t *exch;
@@ -188,5 +212,5 @@
 	if (sess_ns == NULL) {
 		exch = async_exchange_begin(&session_ns);
-		sess_ns = async_connect_me_to(exch, 0, 0, 0);
+		sess_ns = async_connect_me_to(exch, 0, 0, 0, rc);
 		async_exchange_end(exch);
 		if (sess_ns == NULL)
Index: uspace/lib/c/generic/pci.c
===================================================================
--- uspace/lib/c/generic/pci.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/pci.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -163,7 +163,10 @@
 
 		alloc_size = act_size;
-		ids = realloc(ids, alloc_size);
-		if (ids == NULL)
+		service_id_t *tmp = realloc(ids, alloc_size);
+		if (tmp == NULL) {
+			free(ids);
 			return ENOMEM;
+		}
+		ids = tmp;
 	}
 
Index: uspace/lib/c/generic/rtld/module.c
===================================================================
--- uspace/lib/c/generic/rtld/module.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/rtld/module.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -40,4 +40,5 @@
 #include <errno.h>
 #include <loader/pcb.h>
+#include <stdalign.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -353,5 +354,5 @@
 #ifdef CONFIG_TLS_VARIANT_1
 	rtld->tls_size = sizeof(tcb_t);
-	rtld->tls_align = _Alignof(tcb_t);
+	rtld->tls_align = alignof(tcb_t);
 
 	list_foreach(rtld->modules, modules_link, module_t, m) {
@@ -366,5 +367,5 @@
 #else
 	rtld->tls_size = 0;
-	rtld->tls_align = _Alignof(tcb_t);
+	rtld->tls_align = alignof(tcb_t);
 
 	list_foreach(rtld->modules, modules_link, module_t, m) {
Index: uspace/lib/c/generic/stats.c
===================================================================
--- uspace/lib/c/generic/stats.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/stats.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -184,4 +184,30 @@
 }
 
+/** Get IPC connections statistics.
+ *
+ * @param count Number of records returned.
+ *
+ * @return Array of stats_ipcc_t structures.
+ *         If non-NULL then it should be eventually freed
+ *         by free().
+ *
+ */
+stats_ipcc_t *stats_get_ipccs(size_t *count)
+{
+	size_t size = 0;
+	stats_ipcc_t *stats_ipccs =
+	    (stats_ipcc_t *) sysinfo_get_data("system.ipccs", &size);
+
+	if ((size % sizeof(stats_ipcc_t)) != 0) {
+		if (stats_ipccs != NULL)
+			free(stats_ipccs);
+		*count = 0;
+		return NULL;
+	}
+
+	*count = size / sizeof(stats_ipcc_t);
+	return stats_ipccs;
+}
+
 /** Get exception statistics.
  *
Index: uspace/lib/c/generic/stdio/sstream.c
===================================================================
--- uspace/lib/c/generic/stdio/sstream.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/stdio/sstream.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -37,5 +37,5 @@
 #include <errno.h>
 #include <adt/list.h>
-#include <wchar.h>
+#include <uchar.h>
 #include "../private/stdio.h"
 #include "../private/sstream.h"
Index: uspace/lib/c/generic/str.c
===================================================================
--- uspace/lib/c/generic/str.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/str.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -42,5 +42,5 @@
  * strings, called just strings are encoded in UTF-8. Wide strings (encoded
  * in UTF-32) are supported to a limited degree. A single character is
- * represented as wchar_t.@n
+ * represented as char32_t.@n
  *
  * Overview of the terminology:@n
@@ -50,6 +50,6 @@
  *  byte                  8 bits stored in uint8_t (unsigned 8 bit integer)
  *
- *  character             UTF-32 encoded Unicode character, stored in wchar_t
- *                        (signed 32 bit integer), code points 0 .. 1114111
+ *  character             UTF-32 encoded Unicode character, stored in char32_t
+ *                        (unsigned 32 bit integer), code points 0 .. 1114111
  *                        are valid
  *
@@ -61,5 +61,5 @@
  *
  *  wide string           UTF-32 encoded NULL-terminated Unicode string,
- *                        wchar_t *
+ *                        char32_t *
  *
  *  [wide] string size    number of BYTES in a [wide] string (excluding
@@ -100,5 +100,5 @@
  * A specific character inside a [wide] string can be referred to by:@n
  *
- *  pointer (char *, wchar_t *)
+ *  pointer (char *, char32_t *)
  *  byte offset (size_t)
  *  character index (size_t)
@@ -119,11 +119,4 @@
 #include <mem.h>
 
-/** Check the condition if wchar_t is signed */
-#ifdef __WCHAR_UNSIGNED__
-#define WCHAR_SIGNED_CHECK(cond)  (true)
-#else
-#define WCHAR_SIGNED_CHECK(cond)  (cond)
-#endif
-
 /** Byte mask consisting of lowest @n bits (out of 8) */
 #define LO_MASK_8(n)  ((uint8_t) ((1 << (n)) - 1))
@@ -153,5 +146,5 @@
  *
  */
-wchar_t str_decode(const char *str, size_t *offset, size_t size)
+char32_t str_decode(const char *str, size_t *offset, size_t size)
 {
 	if (*offset + 1 > size)
@@ -190,5 +183,5 @@
 		return U_SPECIAL;
 
-	wchar_t ch = b0 & LO_MASK_8(b0_bits);
+	char32_t ch = b0 & LO_MASK_8(b0_bits);
 
 	/* Decode continuation bytes */
@@ -201,5 +194,5 @@
 
 		/* Shift data bits to ch */
-		ch = (ch << CONT_BITS) | (wchar_t) (b & LO_MASK_8(CONT_BITS));
+		ch = (ch << CONT_BITS) | (char32_t) (b & LO_MASK_8(CONT_BITS));
 		cbytes--;
 	}
@@ -223,5 +216,5 @@
  *
  */
-wchar_t str_decode_reverse(const char *str, size_t *offset, size_t size)
+char32_t str_decode_reverse(const char *str, size_t *offset, size_t size)
 {
 	if (*offset == 0)
@@ -266,5 +259,5 @@
  *         code was invalid.
  */
-errno_t chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
+errno_t chr_encode(const char32_t ch, char *str, size_t *offset, size_t size)
 {
 	if (*offset >= size)
@@ -352,7 +345,7 @@
  *
  */
-size_t wstr_size(const wchar_t *str)
-{
-	return (wstr_length(str) * sizeof(wchar_t));
+size_t wstr_size(const char32_t *str)
+{
+	return (wstr_length(str) * sizeof(char32_t));
 }
 
@@ -417,7 +410,7 @@
  *
  */
-size_t wstr_nsize(const wchar_t *str, size_t max_size)
-{
-	return (wstr_nlength(str, max_size) * sizeof(wchar_t));
+size_t wstr_nsize(const char32_t *str, size_t max_size)
+{
+	return (wstr_nlength(str, max_size) * sizeof(char32_t));
 }
 
@@ -435,7 +428,7 @@
  *
  */
-size_t wstr_lsize(const wchar_t *str, size_t max_len)
-{
-	return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));
+size_t wstr_lsize(const char32_t *str, size_t max_len)
+{
+	return (wstr_nlength(str, max_len * sizeof(char32_t)) * sizeof(char32_t));
 }
 
@@ -465,5 +458,5 @@
  *
  */
-size_t wstr_length(const wchar_t *wstr)
+size_t wstr_length(const char32_t *wstr)
 {
 	size_t len = 0;
@@ -502,13 +495,13 @@
  *
  */
-size_t wstr_nlength(const wchar_t *str, size_t size)
+size_t wstr_nlength(const char32_t *str, size_t size)
 {
 	size_t len = 0;
-	size_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
+	size_t limit = ALIGN_DOWN(size, sizeof(char32_t));
 	size_t offset = 0;
 
 	while ((offset < limit) && (*str++ != 0)) {
 		len++;
-		offset += sizeof(wchar_t);
+		offset += sizeof(char32_t);
 	}
 
@@ -521,5 +514,5 @@
  * @return	Width of character in cells.
  */
-size_t chr_width(wchar_t ch)
+size_t chr_width(char32_t ch)
 {
 	return 1;
@@ -535,5 +528,5 @@
 	size_t width = 0;
 	size_t offset = 0;
-	wchar_t ch;
+	char32_t ch;
 
 	while ((ch = str_decode(str, &offset, STR_NO_LIMIT)) != 0)
@@ -548,7 +541,7 @@
  *
  */
-bool ascii_check(wchar_t ch)
-{
-	if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
+bool ascii_check(char32_t ch)
+{
+	if (ch <= 127)
 		return true;
 
@@ -561,7 +554,7 @@
  *
  */
-bool chr_check(wchar_t ch)
-{
-	if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
+bool chr_check(char32_t ch)
+{
+	if (ch <= 1114111)
 		return true;
 
@@ -589,6 +582,6 @@
 int str_cmp(const char *s1, const char *s2)
 {
-	wchar_t c1 = 0;
-	wchar_t c2 = 0;
+	char32_t c1 = 0;
+	char32_t c2 = 0;
 
 	size_t off1 = 0;
@@ -636,6 +629,6 @@
 int str_lcmp(const char *s1, const char *s2, size_t max_len)
 {
-	wchar_t c1 = 0;
-	wchar_t c2 = 0;
+	char32_t c1 = 0;
+	char32_t c2 = 0;
 
 	size_t off1 = 0;
@@ -688,6 +681,6 @@
 int str_casecmp(const char *s1, const char *s2)
 {
-	wchar_t c1 = 0;
-	wchar_t c2 = 0;
+	char32_t c1 = 0;
+	char32_t c2 = 0;
 
 	size_t off1 = 0;
@@ -736,6 +729,6 @@
 int str_lcasecmp(const char *s1, const char *s2, size_t max_len)
 {
-	wchar_t c1 = 0;
-	wchar_t c2 = 0;
+	char32_t c1 = 0;
+	char32_t c2 = 0;
 
 	size_t off1 = 0;
@@ -780,6 +773,6 @@
 bool str_test_prefix(const char *s, const char *p)
 {
-	wchar_t c1 = 0;
-	wchar_t c2 = 0;
+	char32_t c1 = 0;
+	char32_t c2 = 0;
 
 	size_t off1 = 0;
@@ -801,4 +794,30 @@
 
 	return false;
+}
+
+/** Get a string suffix.
+ *
+ * Return a string suffix defined by the prefix length.
+ *
+ * @param s             The string to get the suffix from.
+ * @param prefix_length Number of prefix characters to ignore.
+ *
+ * @return String suffix.
+ *
+ */
+const char *str_suffix(const char *s, size_t prefix_length)
+{
+	size_t off = 0;
+	size_t i = 0;
+
+	while (true) {
+		str_decode(s, &off, STR_NO_LIMIT);
+		i++;
+
+		if (i >= prefix_length)
+			break;
+	}
+
+	return s + off;
 }
 
@@ -824,5 +843,5 @@
 	size_t dest_off = 0;
 
-	wchar_t ch;
+	char32_t ch;
 	while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) {
 		if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
@@ -857,5 +876,5 @@
 	size_t dest_off = 0;
 
-	wchar_t ch;
+	char32_t ch;
 	while ((ch = str_decode(src, &src_off, n)) != 0) {
 		if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
@@ -961,7 +980,7 @@
  * @param src	Source wide string.
  */
-void wstr_to_str(char *dest, size_t size, const wchar_t *src)
-{
-	wchar_t ch;
+void wstr_to_str(char *dest, size_t size, const char32_t *src)
+{
+	char32_t ch;
 	size_t src_idx;
 	size_t dest_off;
@@ -996,5 +1015,5 @@
 {
 	size_t idx = 0, dest_off = 0;
-	wchar_t ch;
+	char32_t ch;
 	errno_t rc = EOK;
 
@@ -1040,5 +1059,5 @@
 	size_t offset = 0;
 	size_t idx = 0;
-	wchar_t c;
+	char32_t c;
 
 	assert(dlen > 0);
@@ -1097,9 +1116,9 @@
  * @return	New string.
  */
-char *wstr_to_astr(const wchar_t *src)
+char *wstr_to_astr(const char32_t *src)
 {
 	char dbuf[STR_BOUNDS(1)];
 	char *str;
-	wchar_t ch;
+	char32_t ch;
 
 	size_t src_idx;
@@ -1147,9 +1166,9 @@
  * @param src	Source string.
  */
-void str_to_wstr(wchar_t *dest, size_t dlen, const char *src)
+void str_to_wstr(char32_t *dest, size_t dlen, const char *src)
 {
 	size_t offset;
 	size_t di;
-	wchar_t c;
+	char32_t c;
 
 	assert(dlen > 0);
@@ -1176,9 +1195,9 @@
  * @param src	Source string.
  */
-wchar_t *str_to_awstr(const char *str)
+char32_t *str_to_awstr(const char *str)
 {
 	size_t len = str_length(str);
 
-	wchar_t *wstr = calloc(len + 1, sizeof(wchar_t));
+	char32_t *wstr = calloc(len + 1, sizeof(char32_t));
 	if (wstr == NULL)
 		return NULL;
@@ -1195,7 +1214,7 @@
  * @return Pointer to character in @a str or NULL if not found.
  */
-char *str_chr(const char *str, wchar_t ch)
-{
-	wchar_t acc;
+char *str_chr(const char *str, char32_t ch)
+{
+	char32_t acc;
 	size_t off = 0;
 	size_t last = 0;
@@ -1237,9 +1256,9 @@
  * @param ch  Character to remove.
  */
-void str_rtrim(char *str, wchar_t ch)
+void str_rtrim(char *str, char32_t ch)
 {
 	size_t off = 0;
 	size_t pos = 0;
-	wchar_t c;
+	char32_t c;
 	bool update_last_chunk = true;
 	char *last_chunk = NULL;
@@ -1265,7 +1284,7 @@
  * @param ch  Character to remove.
  */
-void str_ltrim(char *str, wchar_t ch)
-{
-	wchar_t acc;
+void str_ltrim(char *str, char32_t ch)
+{
+	char32_t acc;
 	size_t off = 0;
 	size_t pos = 0;
@@ -1293,7 +1312,7 @@
  * @return Pointer to character in @a str or NULL if not found.
  */
-char *str_rchr(const char *str, wchar_t ch)
-{
-	wchar_t acc;
+char *str_rchr(const char *str, char32_t ch)
+{
+	char32_t acc;
 	size_t off = 0;
 	size_t last = 0;
@@ -1323,5 +1342,5 @@
  *
  */
-bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos)
+bool wstr_linsert(char32_t *str, char32_t ch, size_t pos, size_t max_pos)
 {
 	size_t len = wstr_length(str);
@@ -1351,5 +1370,5 @@
  *
  */
-bool wstr_remove(wchar_t *str, size_t pos)
+bool wstr_remove(char32_t *str, size_t pos)
 {
 	size_t len = wstr_length(str);
@@ -1448,5 +1467,5 @@
 	size_t cur;
 	size_t tmp;
-	wchar_t ch;
+	char32_t ch;
 
 	/* Skip over leading delimiters. */
Index: uspace/lib/c/generic/str_error.c
===================================================================
--- uspace/lib/c/generic/str_error.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/str_error.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -63,5 +63,5 @@
 
 #undef __errno_entry
-#define __errno_entry(name, num, desc) "[" #name "]" desc,
+#define __errno_entry(name, num, desc) "[" #name "] " desc,
 
 static const char *err_desc[] = {
Index: uspace/lib/c/generic/task.c
===================================================================
--- uspace/lib/c/generic/task.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/task.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -181,7 +181,8 @@
 
 	/* Connect to a program loader. */
-	loader_t *ldr = loader_connect();
+	errno_t rc;
+	loader_t *ldr = loader_connect(&rc);
 	if (ldr == NULL)
-		return EREFUSED;
+		return rc;
 
 	bool wait_initialized = false;
@@ -189,5 +190,5 @@
 	/* Get task ID. */
 	task_id_t task_id;
-	errno_t rc = loader_get_task_id(ldr, &task_id);
+	rc = loader_get_task_id(ldr, &task_id);
 	if (rc != EOK)
 		goto error;
@@ -250,8 +251,7 @@
 	/* Start a debug session if requested */
 	if (rsess != NULL) {
-		ksess = async_connect_kbox(task_id);
+		ksess = async_connect_kbox(task_id, &rc);
 		if (ksess == NULL) {
 			/* Most likely debugging support is not compiled in */
-			rc = ENOTSUP;
 			goto error;
 		}
@@ -402,7 +402,8 @@
 errno_t task_setup_wait(task_id_t id, task_wait_t *wait)
 {
-	async_sess_t *sess_ns = ns_session_get();
+	errno_t rc;
+	async_sess_t *sess_ns = ns_session_get(&rc);
 	if (sess_ns == NULL)
-		return EIO;
+		return rc;
 
 	async_exch_t *exch = async_exchange_begin(sess_ns);
@@ -484,10 +485,11 @@
 errno_t task_retval(int val)
 {
-	async_sess_t *sess_ns = ns_session_get();
+	errno_t rc;
+	async_sess_t *sess_ns = ns_session_get(&rc);
 	if (sess_ns == NULL)
-		return EIO;
+		return rc;
 
 	async_exch_t *exch = async_exchange_begin(sess_ns);
-	errno_t rc = (errno_t) async_req_1_0(exch, NS_RETVAL, val);
+	rc = (errno_t) async_req_1_0(exch, NS_RETVAL, val);
 	async_exchange_end(exch);
 
Index: uspace/lib/c/generic/thread/tls.c
===================================================================
--- uspace/lib/c/generic/thread/tls.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/thread/tls.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -37,4 +37,5 @@
 
 #include <assert.h>
+#include <stdalign.h>
 #include <stddef.h>
 #include <align.h>
@@ -69,5 +70,5 @@
 #else
 	size_t tls_size = tls ? tls->p_memsz : 0;
-	return -ALIGN_UP((ptrdiff_t) tls_size, max(tls_align, _Alignof(tcb_t)));
+	return -ALIGN_UP((ptrdiff_t) tls_size, max(tls_align, alignof(tcb_t)));
 #endif
 }
@@ -104,8 +105,8 @@
 #else
 	size_t alloc_size =
-	    ALIGN_UP(tls_size, max(tls_align, _Alignof(tcb_t))) + sizeof(tcb_t);
-#endif
-
-	void *area = alloc(max(tls_align, _Alignof(tcb_t)), alloc_size);
+	    ALIGN_UP(tls_size, max(tls_align, alignof(tcb_t))) + sizeof(tcb_t);
+#endif
+
+	void *area = alloc(max(tls_align, alignof(tcb_t)), alloc_size);
 	if (!area)
 		return NULL;
@@ -187,5 +188,5 @@
 	tls_free_arch(tcb,
 	    ALIGN_UP(tls->p_memsz, tls->p_align) + sizeof(tcb_t),
-	    max(tls->p_align, _Alignof(tcb_t)));
+	    max(tls->p_align, alignof(tcb_t)));
 }
 
Index: uspace/lib/c/generic/udebug.c
===================================================================
--- uspace/lib/c/generic/udebug.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/udebug.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -42,5 +42,8 @@
 {
 	async_exch_t *exch = async_exchange_begin(sess);
-	return async_req_1_0(exch, IPC_M_DEBUG, UDEBUG_M_BEGIN);
+	errno_t rc = async_req_1_0(exch, IPC_M_DEBUG, UDEBUG_M_BEGIN);
+	async_exchange_end(exch);
+
+	return rc;
 }
 
@@ -48,5 +51,8 @@
 {
 	async_exch_t *exch = async_exchange_begin(sess);
-	return async_req_1_0(exch, IPC_M_DEBUG, UDEBUG_M_END);
+	errno_t rc = async_req_1_0(exch, IPC_M_DEBUG, UDEBUG_M_END);
+	async_exchange_end(exch);
+
+	return rc;
 }
 
@@ -54,5 +60,8 @@
 {
 	async_exch_t *exch = async_exchange_begin(sess);
-	return async_req_2_0(exch, IPC_M_DEBUG, UDEBUG_M_SET_EVMASK, mask);
+	errno_t rc = async_req_2_0(exch, IPC_M_DEBUG, UDEBUG_M_SET_EVMASK, mask);
+	async_exchange_end(exch);
+
+	return rc;
 }
 
@@ -65,4 +74,5 @@
 	errno_t rc = async_req_3_3(exch, IPC_M_DEBUG, UDEBUG_M_THREAD_READ,
 	    (sysarg_t) buffer, n, NULL, &a_copied, &a_needed);
+	async_exchange_end(exch);
 
 	*copied = (size_t) a_copied;
@@ -80,4 +90,5 @@
 	errno_t rc = async_req_3_3(exch, IPC_M_DEBUG, UDEBUG_M_NAME_READ,
 	    (sysarg_t) buffer, n, NULL, &a_copied, &a_needed);
+	async_exchange_end(exch);
 
 	*copied = (size_t) a_copied;
@@ -95,4 +106,5 @@
 	errno_t rc = async_req_3_3(exch, IPC_M_DEBUG, UDEBUG_M_AREAS_READ,
 	    (sysarg_t) buffer, n, NULL, &a_copied, &a_needed);
+	async_exchange_end(exch);
 
 	*copied = (size_t) a_copied;
@@ -105,6 +117,9 @@
 {
 	async_exch_t *exch = async_exchange_begin(sess);
-	return async_req_4_0(exch, IPC_M_DEBUG, UDEBUG_M_MEM_READ,
+	errno_t rc = async_req_4_0(exch, IPC_M_DEBUG, UDEBUG_M_MEM_READ,
 	    (sysarg_t) buffer, addr, n);
+	async_exchange_end(exch);
+
+	return rc;
 }
 
@@ -112,6 +127,9 @@
 {
 	async_exch_t *exch = async_exchange_begin(sess);
-	return async_req_3_0(exch, IPC_M_DEBUG, UDEBUG_M_ARGS_READ,
+	errno_t rc = async_req_3_0(exch, IPC_M_DEBUG, UDEBUG_M_ARGS_READ,
 	    tid, (sysarg_t) buffer);
+	async_exchange_end(exch);
+
+	return rc;
 }
 
@@ -119,6 +137,9 @@
 {
 	async_exch_t *exch = async_exchange_begin(sess);
-	return async_req_3_0(exch, IPC_M_DEBUG, UDEBUG_M_REGS_READ,
+	errno_t rc = async_req_3_0(exch, IPC_M_DEBUG, UDEBUG_M_REGS_READ,
 	    tid, (sysarg_t) buffer);
+	async_exchange_end(exch);
+
+	return rc;
 }
 
@@ -131,4 +152,5 @@
 	errno_t rc = async_req_2_3(exch, IPC_M_DEBUG, UDEBUG_M_GO,
 	    tid, &a_ev_type, val0, val1);
+	async_exchange_end(exch);
 
 	*ev_type = a_ev_type;
@@ -139,5 +161,8 @@
 {
 	async_exch_t *exch = async_exchange_begin(sess);
-	return async_req_2_0(exch, IPC_M_DEBUG, UDEBUG_M_STOP, tid);
+	errno_t rc = async_req_2_0(exch, IPC_M_DEBUG, UDEBUG_M_STOP, tid);
+	async_exchange_end(exch);
+
+	return rc;
 }
 
Index: uspace/lib/c/generic/uuid.c
===================================================================
--- uspace/lib/c/generic/uuid.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/uuid.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -189,6 +189,8 @@
 	int ret = snprintf(str, size, format, uuid->b[0], uuid->b[1], uuid->b[2], uuid->b[3], uuid->b[4], uuid->b[5], uuid->b[6], uuid->b[7], uuid->b[8], uuid->b[9], uuid->b[10], uuid->b[11], uuid->b[12], uuid->b[13], uuid->b[14], uuid->b[15]);
 
-	if (ret != 36)
-		return EINVAL;
+	if (ret != 36) {
+		free(str);
+		return EINVAL;
+	}
 
 	*rstr = str;
Index: uspace/lib/c/generic/vbd.c
===================================================================
--- uspace/lib/c/generic/vbd.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/vbd.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -231,7 +231,10 @@
 
 		alloc_size = act_size;
-		ids = realloc(ids, alloc_size);
-		if (ids == NULL)
+		service_id_t *tmp = realloc(ids, alloc_size);
+		if (tmp == NULL) {
+			free(ids);
 			return ENOMEM;
+		}
+		ids = tmp;
 	}
 
Index: uspace/lib/c/generic/vfs/vfs.c
===================================================================
--- uspace/lib/c/generic/vfs/vfs.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/vfs/vfs.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -322,5 +322,5 @@
 	while (vfs_sess == NULL) {
 		vfs_sess = service_connect_blocking(SERVICE_VFS, INTERFACE_VFS,
-		    0);
+		    0, NULL);
 	}
 
Index: uspace/lib/c/generic/vol.c
===================================================================
--- uspace/lib/c/generic/vol.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/generic/vol.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -168,7 +168,10 @@
 
 		alloc_size = act_size;
-		ids = realloc(ids, alloc_size);
-		if (ids == NULL)
+		service_id_t *temp = realloc(ids, alloc_size);
+		if (temp == NULL) {
+			free(ids);
 			return ENOMEM;
+		}
+		ids = temp;
 	}
 
Index: uspace/lib/c/include/async.h
===================================================================
--- uspace/lib/c/include/async.h	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/include/async.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -275,12 +275,12 @@
 
 extern async_sess_t *async_connect_me_to(async_exch_t *, iface_t, sysarg_t,
-    sysarg_t);
+    sysarg_t, errno_t *);
 extern async_sess_t *async_connect_me_to_blocking(async_exch_t *, iface_t,
-    sysarg_t, sysarg_t);
-extern async_sess_t *async_connect_kbox(task_id_t);
+    sysarg_t, sysarg_t, errno_t *);
+extern async_sess_t *async_connect_kbox(task_id_t, errno_t *);
 
 extern errno_t async_connect_to_me(async_exch_t *, iface_t, sysarg_t, sysarg_t);
 
-extern errno_t async_hangup(async_sess_t *);
+extern void async_hangup(async_sess_t *);
 
 extern async_exch_t *async_exchange_begin(async_sess_t *);
Index: uspace/lib/c/include/io/charfield.h
===================================================================
--- uspace/lib/c/include/io/charfield.h	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/include/io/charfield.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -38,5 +38,5 @@
 
 #include <stdbool.h>
-#include <wchar.h>
+#include <uchar.h>
 #include <io/color.h>
 #include <io/style.h>
@@ -77,5 +77,5 @@
 
 typedef struct {
-	wchar_t ch;
+	char32_t ch;
 	char_attrs_t attrs;
 	char_flags_t flags;
Index: uspace/lib/c/include/io/chargrid.h
===================================================================
--- uspace/lib/c/include/io/chargrid.h	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/include/io/chargrid.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -79,5 +79,5 @@
 extern sysarg_t chargrid_get_top_row(chargrid_t *);
 
-extern sysarg_t chargrid_putwchar(chargrid_t *, wchar_t, bool);
+extern sysarg_t chargrid_putuchar(chargrid_t *, char32_t, bool);
 extern sysarg_t chargrid_newline(chargrid_t *);
 extern sysarg_t chargrid_tabstop(chargrid_t *, sysarg_t);
Index: uspace/lib/c/include/io/input.h
===================================================================
--- uspace/lib/c/include/io/input.h	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/include/io/input.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -50,5 +50,5 @@
 	errno_t (*active)(input_t *);
 	errno_t (*deactive)(input_t *);
-	errno_t (*key)(input_t *, kbd_event_type_t, keycode_t, keymod_t, wchar_t);
+	errno_t (*key)(input_t *, kbd_event_type_t, keycode_t, keymod_t, char32_t);
 	errno_t (*move)(input_t *, int, int);
 	errno_t (*abs_move)(input_t *, unsigned, unsigned, unsigned, unsigned);
Index: uspace/lib/c/include/io/kbd_event.h
===================================================================
--- uspace/lib/c/include/io/kbd_event.h	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/include/io/kbd_event.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -37,4 +37,5 @@
 
 #include <adt/list.h>
+#include <inttypes.h>
 #include <io/keycode.h>
 
@@ -59,5 +60,5 @@
 
 	/** The character that was generated or '\0' for none. */
-	wchar_t c;
+	char32_t c;
 } kbd_event_t;
 
Index: uspace/lib/c/include/io/printf_core.h
===================================================================
--- uspace/lib/c/include/io/printf_core.h	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/include/io/printf_core.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -38,4 +38,5 @@
 #include <stddef.h>
 #include <stdarg.h>
+#include <uchar.h>
 
 /** Structure for specifying output methods for different printf clones. */
@@ -45,5 +46,5 @@
 
 	/* Wide string output function, returns number of printed characters or EOF */
-	int (*wstr_write)(const wchar_t *, size_t, void *);
+	int (*wstr_write)(const char32_t *, size_t, void *);
 
 	/* User data - output stream specification, state, locks, etc. */
Index: uspace/lib/c/include/loader/loader.h
===================================================================
--- uspace/lib/c/include/loader/loader.h	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/include/loader/loader.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -44,5 +44,5 @@
 
 extern errno_t loader_spawn(const char *);
-extern loader_t *loader_connect(void);
+extern loader_t *loader_connect(errno_t *);
 extern errno_t loader_get_task_id(loader_t *, task_id_t *);
 extern errno_t loader_set_cwd(loader_t *);
Index: uspace/lib/c/include/ns.h
===================================================================
--- uspace/lib/c/include/ns.h	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/include/ns.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -43,10 +43,11 @@
     void *);
 extern errno_t service_register_broker(service_t, async_port_handler_t, void *);
-extern async_sess_t *service_connect(service_t, iface_t, sysarg_t);
-extern async_sess_t *service_connect_blocking(service_t, iface_t, sysarg_t);
+extern async_sess_t *service_connect(service_t, iface_t, sysarg_t, errno_t *);
+extern async_sess_t *service_connect_blocking(service_t, iface_t, sysarg_t,
+    errno_t *);
 
 extern errno_t ns_ping(void);
 extern errno_t ns_intro(task_id_t);
-extern async_sess_t *ns_session_get(void);
+extern async_sess_t *ns_session_get(errno_t *);
 
 #endif
Index: uspace/lib/c/include/stats.h
===================================================================
--- uspace/lib/c/include/stats.h	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/include/stats.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -52,4 +52,5 @@
 
 extern stats_thread_t *stats_get_threads(size_t *);
+extern stats_ipcc_t *stats_get_ipccs(size_t *);
 
 extern stats_exc_t *stats_get_exceptions(size_t *);
Index: uspace/lib/c/include/stdio.h
===================================================================
--- uspace/lib/c/include/stdio.h	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/include/stdio.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -42,4 +42,5 @@
 #include <_bits/size_t.h>
 #include <_bits/wchar_t.h>
+#include <_bits/uchar.h>
 #include <_bits/wint_t.h>
 #include <_bits/decls.h>
@@ -123,4 +124,7 @@
 extern wint_t fputwc(wchar_t, FILE *);
 extern wint_t putwchar(wchar_t);
+
+extern wint_t fputuc(char32_t, FILE *);
+extern wint_t putuchar(char32_t);
 
 /* Formatted string output functions */
Index: uspace/lib/c/include/stdlib.h
===================================================================
--- uspace/lib/c/include/stdlib.h	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/include/stdlib.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -38,4 +38,5 @@
 #include <_bits/size_t.h>
 #include <_bits/wchar_t.h>
+#include <_bits/uchar.h>
 #include <_bits/decls.h>
 #include <bsearch.h>
Index: uspace/lib/c/include/str.h
===================================================================
--- uspace/lib/c/include/str.h	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/include/str.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -67,28 +67,28 @@
 __HELENOS_DECLS_BEGIN;
 
-extern wchar_t str_decode(const char *str, size_t *offset, size_t sz);
-extern wchar_t str_decode_reverse(const char *str, size_t *offset, size_t sz);
-extern errno_t chr_encode(wchar_t ch, char *str, size_t *offset, size_t sz);
+extern char32_t str_decode(const char *str, size_t *offset, size_t sz);
+extern char32_t str_decode_reverse(const char *str, size_t *offset, size_t sz);
+extern errno_t chr_encode(char32_t ch, char *str, size_t *offset, size_t sz);
 
 extern size_t str_size(const char *str);
-extern size_t wstr_size(const wchar_t *str);
+extern size_t wstr_size(const char32_t *str);
 
 extern size_t str_nsize(const char *str, size_t max_size);
-extern size_t wstr_nsize(const wchar_t *str, size_t max_size);
+extern size_t wstr_nsize(const char32_t *str, size_t max_size);
 
 extern size_t str_lsize(const char *str, size_t max_len);
-extern size_t wstr_lsize(const wchar_t *str, size_t max_len);
+extern size_t wstr_lsize(const char32_t *str, size_t max_len);
 
 extern size_t str_length(const char *str);
-extern size_t wstr_length(const wchar_t *wstr);
+extern size_t wstr_length(const char32_t *wstr);
 
 extern size_t str_nlength(const char *str, size_t size);
-extern size_t wstr_nlength(const wchar_t *str, size_t size);
+extern size_t wstr_nlength(const char32_t *str, size_t size);
 
-extern size_t chr_width(wchar_t ch);
+extern size_t chr_width(char32_t ch);
 extern size_t str_width(const char *str);
 
-extern bool ascii_check(wchar_t ch);
-extern bool chr_check(wchar_t ch);
+extern bool ascii_check(char32_t ch);
+extern bool chr_check(char32_t ch);
 
 extern int str_cmp(const char *s1, const char *s2);
@@ -98,4 +98,5 @@
 
 extern bool str_test_prefix(const char *s, const char *p);
+extern const char *str_suffix(const char *s, size_t prefix_length);
 
 extern void str_cpy(char *dest, size_t size, const char *src);
@@ -104,21 +105,21 @@
 
 extern errno_t spascii_to_str(char *dest, size_t size, const uint8_t *src, size_t n);
-extern void wstr_to_str(char *dest, size_t size, const wchar_t *src);
-extern char *wstr_to_astr(const wchar_t *src);
-extern void str_to_wstr(wchar_t *dest, size_t dlen, const char *src);
-extern wchar_t *str_to_awstr(const char *src);
+extern void wstr_to_str(char *dest, size_t size, const char32_t *src);
+extern char *wstr_to_astr(const char32_t *src);
+extern void str_to_wstr(char32_t *dest, size_t dlen, const char *src);
+extern char32_t *str_to_awstr(const char *src);
 extern errno_t utf16_to_str(char *dest, size_t size, const uint16_t *src);
 extern errno_t str_to_utf16(uint16_t *dest, size_t dlen, const char *src);
 extern size_t utf16_wsize(const uint16_t *ustr);
 
-extern char *str_chr(const char *str, wchar_t ch);
-extern char *str_rchr(const char *str, wchar_t ch);
+extern char *str_chr(const char *str, char32_t ch);
+extern char *str_rchr(const char *str, char32_t ch);
 extern char *str_str(const char *hs, const char *n);
 
-extern void str_rtrim(char *str, wchar_t ch);
-extern void str_ltrim(char *str, wchar_t ch);
+extern void str_rtrim(char *str, char32_t ch);
+extern void str_ltrim(char *str, char32_t ch);
 
-extern bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos);
-extern bool wstr_remove(wchar_t *str, size_t pos);
+extern bool wstr_linsert(char32_t *str, char32_t ch, size_t pos, size_t max_pos);
+extern bool wstr_remove(char32_t *str, size_t pos);
 
 extern char *str_dup(const char *src);
Index: uspace/lib/c/include/uchar.h
===================================================================
--- uspace/lib/c/include/uchar.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
+++ uspace/lib/c/include/uchar.h	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2020 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+
+#ifndef _LIBC_UCHAR_H_
+#define _LIBC_UCHAR_H_
+
+#include <_bits/uchar.h>
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/c/test/stdlib.c
===================================================================
--- uspace/lib/c/test/stdlib.c	(revision de19d4adc0334d6906982d38962b3f8ec0050aba)
+++ uspace/lib/c/test/stdlib.c	(revision ddb844e7f3c7c26ca821db9add6e4c048aaf9a7b)
@@ -48,6 +48,6 @@
 	(void) sz;
 
-	/* Make sure wchar_t is defined */
-	wchar_t wc = L'\0';
+	/* Make sure char32_t is defined */
+	char32_t wc = L'\0';
 	(void) wc;
 
