Index: uspace/lib/c/generic/io/chardev_srv.c
===================================================================
--- uspace/lib/c/generic/io/chardev_srv.c	(revision 3be9d10120f7923a0b3d52282b8de0b670566c71)
+++ uspace/lib/c/generic/io/chardev_srv.c	(revision 9ce35f067406cfc2d4e59addfe1e84524ba08fa4)
@@ -43,5 +43,5 @@
 static chardev_srv_t *chardev_srv_create(chardev_srvs_t *);
 
-static void chardev_read_srv(chardev_srv_t *srv, cap_call_handle_t callid,
+static void chardev_read_srv(chardev_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -50,8 +50,8 @@
 	size_t nread;
 	errno_t rc;
-	cap_call_handle_t rcallid;
+	cap_call_handle_t rcall_handle;
 
-	if (!async_data_read_receive(&rcallid, &size)) {
-		async_answer_0(callid, EINVAL);
+	if (!async_data_read_receive(&rcall_handle, &size)) {
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -59,12 +59,12 @@
 	buf = malloc(size);
 	if (buf == NULL) {
-		async_answer_0(rcallid, ENOMEM);
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(rcall_handle, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
 
 	if (srv->srvs->ops->read == NULL) {
-		async_answer_0(rcallid, ENOTSUP);
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(rcall_handle, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		free(buf);
 		return;
@@ -73,17 +73,17 @@
 	rc = srv->srvs->ops->read(srv, buf, size, &nread);
 	if (rc != EOK && nread == 0) {
-		async_answer_0(rcallid, rc);
-		async_answer_0(callid, rc);
+		async_answer_0(rcall_handle, rc);
+		async_answer_0(chandle, rc);
 		free(buf);
 		return;
 	}
 
-	async_data_read_finalize(rcallid, buf, nread);
+	async_data_read_finalize(rcall_handle, buf, nread);
 
 	free(buf);
-	async_answer_2(callid, EOK, (sysarg_t) rc, nread);
+	async_answer_2(chandle, EOK, (sysarg_t) rc, nread);
 }
 
-static void chardev_write_srv(chardev_srv_t *srv, cap_call_handle_t callid,
+static void chardev_write_srv(chardev_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -95,10 +95,10 @@
 	rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
 
 	if (srv->srvs->ops->write == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -107,9 +107,9 @@
 	free(data);
 	if (rc != EOK && nwr == 0) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
 
-	async_answer_2(callid, EOK, (sysarg_t) rc, nwr);
+	async_answer_2(chandle, EOK, (sysarg_t) rc, nwr);
 }
 
@@ -132,5 +132,5 @@
 }
 
-errno_t chardev_conn(cap_call_handle_t iid, ipc_call_t *icall, chardev_srvs_t *srvs)
+errno_t chardev_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, chardev_srvs_t *srvs)
 {
 	chardev_srv_t *srv;
@@ -138,5 +138,5 @@
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	srv = chardev_srv_create(srvs);
@@ -152,10 +152,10 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		}
@@ -163,14 +163,14 @@
 		switch (method) {
 		case CHARDEV_READ:
-			chardev_read_srv(srv, callid, &call);
+			chardev_read_srv(srv, chandle, &call);
 			break;
 		case CHARDEV_WRITE:
-			chardev_write_srv(srv, callid, &call);
+			chardev_write_srv(srv, chandle, &call);
 			break;
 		default:
 			if (srv->srvs->ops->def_handler != NULL)
-				srv->srvs->ops->def_handler(srv, callid, &call);
+				srv->srvs->ops->def_handler(srv, chandle, &call);
 			else
-				async_answer_0(callid, ENOTSUP);
+				async_answer_0(chandle, ENOTSUP);
 		}
 	}
Index: uspace/lib/c/generic/io/con_srv.c
===================================================================
--- uspace/lib/c/generic/io/con_srv.c	(revision 3be9d10120f7923a0b3d52282b8de0b670566c71)
+++ uspace/lib/c/generic/io/con_srv.c	(revision 9ce35f067406cfc2d4e59addfe1e84524ba08fa4)
@@ -66,5 +66,5 @@
 }
 
-static void con_read_srv(con_srv_t *srv, cap_call_handle_t callid,
+static void con_read_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -72,8 +72,8 @@
 	size_t size;
 	errno_t rc;
-	cap_call_handle_t rcallid;
-
-	if (!async_data_read_receive(&rcallid, &size)) {
-		async_answer_0(callid, EINVAL);
+	cap_call_handle_t rcall_handle;
+
+	if (!async_data_read_receive(&rcall_handle, &size)) {
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -81,12 +81,12 @@
 	buf = malloc(size);
 	if (buf == NULL) {
-		async_answer_0(rcallid, ENOMEM);
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(rcall_handle, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
 
 	if (srv->srvs->ops->read == NULL) {
-		async_answer_0(rcallid, ENOTSUP);
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(rcall_handle, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		free(buf);
 		return;
@@ -96,17 +96,17 @@
 	rc = srv->srvs->ops->read(srv, buf, size, &nread);
 	if (rc != EOK) {
-		async_answer_0(rcallid, rc);
-		async_answer_0(callid, rc);
+		async_answer_0(rcall_handle, rc);
+		async_answer_0(chandle, rc);
 		free(buf);
 		return;
 	}
 
-	async_data_read_finalize(rcallid, buf, nread);
+	async_data_read_finalize(rcall_handle, buf, nread);
 	free(buf);
 
-	async_answer_1(callid, EOK, nread);
-}
-
-static void con_write_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_1(chandle, EOK, nread);
+}
+
+static void con_write_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -117,10 +117,10 @@
 	rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
 
 	if (srv->srvs->ops->write == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -130,32 +130,32 @@
 	free(data);
 
-	async_answer_1(callid, rc, nwritten);
-}
-
-static void con_sync_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_1(chandle, rc, nwritten);
+}
+
+static void con_sync_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
 	if (srv->srvs->ops->sync == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->sync(srv);
-	async_answer_0(callid, EOK);
-}
-
-static void con_clear_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_clear_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
 	if (srv->srvs->ops->clear == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->clear(srv);
-	async_answer_0(callid, EOK);
-}
-
-static void con_set_pos_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_set_pos_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -167,13 +167,13 @@
 
 	if (srv->srvs->ops->set_pos == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->set_pos(srv, col, row);
-	async_answer_0(callid, EOK);
-}
-
-static void con_get_pos_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_get_pos_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -183,13 +183,13 @@
 
 	if (srv->srvs->ops->get_pos == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	rc = srv->srvs->ops->get_pos(srv, &col, &row);
-	async_answer_2(callid, rc, col, row);
-}
-
-static void con_get_size_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_2(chandle, rc, col, row);
+}
+
+static void con_get_size_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -199,13 +199,13 @@
 
 	if (srv->srvs->ops->get_size == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	rc = srv->srvs->ops->get_size(srv, &cols, &rows);
-	async_answer_2(callid, rc, cols, rows);
-}
-
-static void con_get_color_cap_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_2(chandle, rc, cols, rows);
+}
+
+static void con_get_color_cap_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -214,13 +214,13 @@
 
 	if (srv->srvs->ops->get_color_cap == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	rc = srv->srvs->ops->get_color_cap(srv, &ccap);
-	async_answer_1(callid, rc, (sysarg_t)ccap);
-}
-
-static void con_set_style_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_1(chandle, rc, (sysarg_t)ccap);
+}
+
+static void con_set_style_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -230,13 +230,13 @@
 
 	if (srv->srvs->ops->set_style == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->set_style(srv, style);
-	async_answer_0(callid, EOK);
-}
-
-static void con_set_color_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_set_color_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -250,13 +250,13 @@
 
 	if (srv->srvs->ops->set_color == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->set_color(srv, bgcolor, fgcolor, flags);
-	async_answer_0(callid, EOK);
-}
-
-static void con_set_rgb_color_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_set_rgb_color_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -268,13 +268,13 @@
 
 	if (srv->srvs->ops->set_rgb_color == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->set_rgb_color(srv, bgcolor, fgcolor);
-	async_answer_0(callid, EOK);
-}
-
-static void con_set_cursor_visibility_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_set_cursor_visibility_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -284,13 +284,13 @@
 
 	if (srv->srvs->ops->set_cursor_visibility == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->set_cursor_visibility(srv, show);
-	async_answer_0(callid, EOK);
-}
-
-static void con_get_event_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_get_event_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -300,5 +300,5 @@
 
 	if (srv->srvs->ops->get_event == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -306,5 +306,5 @@
 	rc = srv->srvs->ops->get_event(srv, &event);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
@@ -312,9 +312,9 @@
 	rc = console_ev_encode(&event, &result);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		return;
-	}
-
-	async_answer_5(callid, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
+		async_answer_0(chandle, rc);
+		return;
+	}
+
+	async_answer_5(chandle, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
 	    IPC_GET_ARG3(result), IPC_GET_ARG4(result), IPC_GET_ARG5(result));
 }
@@ -340,5 +340,5 @@
 }
 
-errno_t con_conn(cap_call_handle_t iid, ipc_call_t *icall, con_srvs_t *srvs)
+errno_t con_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, con_srvs_t *srvs)
 {
 	con_srv_t *srv;
@@ -346,5 +346,5 @@
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	srv = con_srv_create(srvs);
@@ -366,19 +366,19 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = 0;
-
-		while (callid == 0) {
+		cap_call_handle_t chandle = 0;
+
+		while (chandle == 0) {
 			/* XXX Need to be able to abort immediately */
-			callid = async_get_call_timeout(&call,
+			chandle = async_get_call_timeout(&call,
 			    srvs->abort_timeout);
 
 			if (srv->srvs->aborted) {
-				if (callid != 0)
-					async_answer_0(callid, EINTR);
+				if (chandle != 0)
+					async_answer_0(chandle, EINTR);
 				break;
 			}
 		}
 
-		if (callid == 0)
+		if (chandle == 0)
 			break;
 
@@ -387,5 +387,5 @@
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		}
@@ -393,44 +393,44 @@
 		switch (method) {
 		case VFS_OUT_READ:
-			con_read_srv(srv, callid, &call);
+			con_read_srv(srv, chandle, &call);
 			break;
 		case VFS_OUT_WRITE:
-			con_write_srv(srv, callid, &call);
+			con_write_srv(srv, chandle, &call);
 			break;
 		case VFS_OUT_SYNC:
-			con_sync_srv(srv, callid, &call);
+			con_sync_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_CLEAR:
-			con_clear_srv(srv, callid, &call);
+			con_clear_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_SET_POS:
-			con_set_pos_srv(srv, callid, &call);
+			con_set_pos_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_GET_POS:
-			con_get_pos_srv(srv, callid, &call);
+			con_get_pos_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_GET_SIZE:
-			con_get_size_srv(srv, callid, &call);
+			con_get_size_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_GET_COLOR_CAP:
-			con_get_color_cap_srv(srv, callid, &call);
+			con_get_color_cap_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_SET_STYLE:
-			con_set_style_srv(srv, callid, &call);
+			con_set_style_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_SET_COLOR:
-			con_set_color_srv(srv, callid, &call);
+			con_set_color_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_SET_RGB_COLOR:
-			con_set_rgb_color_srv(srv, callid, &call);
+			con_set_rgb_color_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_SET_CURSOR_VISIBILITY:
-			con_set_cursor_visibility_srv(srv, callid, &call);
+			con_set_cursor_visibility_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_GET_EVENT:
-			con_get_event_srv(srv, callid, &call);
+			con_get_event_srv(srv, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 		}
 	}
Index: uspace/lib/c/generic/io/input.c
===================================================================
--- uspace/lib/c/generic/io/input.c	(revision 3be9d10120f7923a0b3d52282b8de0b670566c71)
+++ uspace/lib/c/generic/io/input.c	(revision 9ce35f067406cfc2d4e59addfe1e84524ba08fa4)
@@ -43,5 +43,5 @@
 #include <stdlib.h>
 
-static void input_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
+static void input_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
 
 errno_t input_open(async_sess_t *sess, input_ev_ops_t *ev_ops,
@@ -92,19 +92,19 @@
 }
 
-static void input_ev_active(input_t *input, cap_call_handle_t callid,
+static void input_ev_active(input_t *input, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
 	errno_t rc = input->ev_ops->active(input);
-	async_answer_0(callid, rc);
-}
-
-static void input_ev_deactive(input_t *input, cap_call_handle_t callid,
+	async_answer_0(chandle, rc);
+}
+
+static void input_ev_deactive(input_t *input, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
 	errno_t rc = input->ev_ops->deactive(input);
-	async_answer_0(callid, rc);
-}
-
-static void input_ev_key(input_t *input, cap_call_handle_t callid,
+	async_answer_0(chandle, rc);
+}
+
+static void input_ev_key(input_t *input, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -121,8 +121,8 @@
 
 	rc = input->ev_ops->key(input, type, key, mods, c);
-	async_answer_0(callid, rc);
-}
-
-static void input_ev_move(input_t *input, cap_call_handle_t callid,
+	async_answer_0(chandle, rc);
+}
+
+static void input_ev_move(input_t *input, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -135,8 +135,8 @@
 
 	rc = input->ev_ops->move(input, dx, dy);
-	async_answer_0(callid, rc);
-}
-
-static void input_ev_abs_move(input_t *input, cap_call_handle_t callid,
+	async_answer_0(chandle, rc);
+}
+
+static void input_ev_abs_move(input_t *input, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -153,8 +153,8 @@
 
 	rc = input->ev_ops->abs_move(input, x, y, max_x, max_y);
-	async_answer_0(callid, rc);
-}
-
-static void input_ev_button(input_t *input, cap_call_handle_t callid,
+	async_answer_0(chandle, rc);
+}
+
+static void input_ev_button(input_t *input, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -167,8 +167,8 @@
 
 	rc = input->ev_ops->button(input, bnum, press);
-	async_answer_0(callid, rc);
-}
-
-static void input_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+	async_answer_0(chandle, rc);
+}
+
+static void input_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	input_t *input = (input_t *)arg;
@@ -176,5 +176,5 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -185,23 +185,23 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case INPUT_EVENT_ACTIVE:
-			input_ev_active(input, callid, &call);
+			input_ev_active(input, chandle, &call);
 			break;
 		case INPUT_EVENT_DEACTIVE:
-			input_ev_deactive(input, callid, &call);
+			input_ev_deactive(input, chandle, &call);
 			break;
 		case INPUT_EVENT_KEY:
-			input_ev_key(input, callid, &call);
+			input_ev_key(input, chandle, &call);
 			break;
 		case INPUT_EVENT_MOVE:
-			input_ev_move(input, callid, &call);
+			input_ev_move(input, chandle, &call);
 			break;
 		case INPUT_EVENT_ABS_MOVE:
-			input_ev_abs_move(input, callid, &call);
+			input_ev_abs_move(input, chandle, &call);
 			break;
 		case INPUT_EVENT_BUTTON:
-			input_ev_button(input, callid, &call);
+			input_ev_button(input, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 		}
 	}