Index: uspace/lib/libc/generic/async.c
===================================================================
--- uspace/lib/libc/generic/async.c	(revision 6b2129280de8a8fbec509eaf90ddda1c3a6a9cc5)
+++ uspace/lib/libc/generic/async.c	(revision c07544d3bde1c0404c275cec848e7fd36db94ac1)
@@ -31,11 +31,12 @@
  */
 /** @file
- */ 
+ */
 
 /**
  * Asynchronous library
  *
- * The aim of this library is facilitating writing programs utilizing the
- * asynchronous nature of HelenOS IPC, yet using a normal way of programming. 
+ * The aim of this library is to provide a facility for writing programs which
+ * utilize the asynchronous nature of HelenOS IPC, yet using a normal way of
+ * programming.
  *
  * You should be able to write very simple multithreaded programs, the async
@@ -43,49 +44,49 @@
  *
  * Default semantics:
- * - async_send_*():	send asynchronously. If the kernel refuses to send
- * 			more messages, [ try to get responses from kernel, if
- * 			nothing found, might try synchronous ]
+ * - async_send_*(): Send asynchronously. If the kernel refuses to send
+ *                   more messages, [ try to get responses from kernel, if
+ *                   nothing found, might try synchronous ]
  *
  * Example of use (pseudo C):
- * 
+ *
  * 1) Multithreaded client application
  *
- * fibril_create(fibril1, ...);
- * fibril_create(fibril2, ...);
- * ...
- *  
- * int fibril1(void *arg)
- * {
- * 	conn = ipc_connect_me_to();
- *	c1 = async_send(conn);
- * 	c2 = async_send(conn);
- * 	async_wait_for(c1);
- * 	async_wait_for(c2);
- * 	...
- * }
+ *   fibril_create(fibril1, ...);
+ *   fibril_create(fibril2, ...);
+ *   ...
+ *
+ *   int fibril1(void *arg)
+ *   {
+ *     conn = ipc_connect_me_to();
+ *     c1 = async_send(conn);
+ *     c2 = async_send(conn);
+ *     async_wait_for(c1);
+ *     async_wait_for(c2);
+ *     ...
+ *   }
  *
  *
  * 2) Multithreaded server application
- * main()
- * {
- * 	async_manager();
- * }
- * 
- *
- * my_client_connection(icallid, *icall)
- * {
- * 	if (want_refuse) {
- * 		ipc_answer_0(icallid, ELIMIT);
- * 		return;
- * 	}
- * 	ipc_answer_0(icallid, EOK);
- *
- * 	callid = async_get_call(&call);
- * 	handle_call(callid, call);
- * 	ipc_answer_2(callid, 1, 2, 3);
- *
- * 	callid = async_get_call(&call);
- * 	....
- * }
+ *
+ *   main()
+ *   {
+ *     async_manager();
+ *   }
+ *
+ *   my_client_connection(icallid, *icall)
+ *   {
+ *     if (want_refuse) {
+ *       ipc_answer_0(icallid, ELIMIT);
+ *       return;
+ *     }
+ *     ipc_answer_0(icallid, EOK);
+ *
+ *     callid = async_get_call(&call);
+ *     handle_call(callid, call);
+ *     ipc_answer_2(callid, 1, 2, 3);
+ *
+ *     callid = async_get_call(&call);
+ *     ...
+ *   }
  *
  */
@@ -105,22 +106,24 @@
 
 atomic_t async_futex = FUTEX_INITIALIZER;
-static hash_table_t conn_hash_table;
-static LIST_INITIALIZE(timeout_list);
 
 /** Structures of this type represent a waiting fibril. */
 typedef struct {
 	/** Expiration time. */
-	struct timeval expires;		
+	struct timeval expires;
+	
 	/** If true, this struct is in the timeout list. */
-	int inlist;
+	bool inlist;
+	
 	/** Timeout list link. */
 	link_t link;
-
+	
 	/** Identification of and link to the waiting fibril. */
 	fid_t fid;
+	
 	/** If true, this fibril is currently active. */
-	int active;
+	bool active;
+	
 	/** If true, we have timed out. */
-	int timedout;
+	bool timedout;
 } awaiter_t;
 
@@ -129,8 +132,9 @@
 	
 	/** If reply was received. */
-	int done;
+	bool done;
+	
 	/** Pointer to where the answer data is stored. */
- 	ipc_call_t *dataptr;
-
+	ipc_call_t *dataptr;
+	
 	ipcarg_t retval;
 } amsg_t;
@@ -148,22 +152,22 @@
 typedef struct {
 	awaiter_t wdata;
-
+	
 	/** Hash table link. */
 	link_t link;
-
+	
 	/** Incoming phone hash. */
-	ipcarg_t in_phone_hash;		
-
+	ipcarg_t in_phone_hash;
+	
 	/** Messages that should be delivered to this fibril. */
-	link_t msg_queue;		
-					 
+	link_t msg_queue;
+	
 	/** Identification of the opening call. */
 	ipc_callid_t callid;
 	/** Call data of the opening call. */
 	ipc_call_t call;
-
+	
 	/** Identification of the closing call. */
 	ipc_callid_t close_callid;
-
+	
 	/** Fibril function that will be used to handle the connection. */
 	void (*cfibril)(ipc_callid_t, ipc_call_t *);
@@ -173,10 +177,4 @@
 __thread connection_t *FIBRIL_connection;
 
-/**
- * If true, it is forbidden to use async_req functions and all preemption is
- * disabled.
- */
-__thread int _in_interrupt_handler;
-
 static void default_client_connection(ipc_callid_t callid, ipc_call_t *call);
 static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call);
@@ -186,4 +184,5 @@
  */
 static async_client_conn_t client_connection = default_client_connection;
+
 /**
  * Pointer to a fibril function that will be used to handle interrupt
@@ -192,44 +191,37 @@
 static async_client_conn_t interrupt_received = default_interrupt_received;
 
-/* 
- * Getter for _in_interrupt_handler. We need to export the value of this thread
- * local variable to other modules, but the binutils 2.18 linkers die on an
- * attempt to export this symbol in the header file. For now, consider this as a
- * workaround.
- */
-bool in_interrupt_handler(void)
-{
-	return _in_interrupt_handler;
-}
-
-#define CONN_HASH_TABLE_CHAINS	32
+
+static hash_table_t conn_hash_table;
+static LIST_INITIALIZE(timeout_list);
+
+
+#define CONN_HASH_TABLE_CHAINS  32
 
 /** Compute hash into the connection hash table based on the source phone hash.
  *
- * @param key		Pointer to source phone hash.
- *
- * @return		Index into the connection hash table.
+ * @param key Pointer to source phone hash.
+ *
+ * @return Index into the connection hash table.
+ *
  */
 static hash_index_t conn_hash(unsigned long *key)
 {
 	assert(key);
-	return ((*key) >> 4) % CONN_HASH_TABLE_CHAINS;
+	return (((*key) >> 4) % CONN_HASH_TABLE_CHAINS);
 }
 
 /** Compare hash table item with a key.
  *
- * @param key		Array containing the source phone hash as the only item.
- * @param keys		Expected 1 but ignored.
- * @param item		Connection hash table item.
- *
- * @return		True on match, false otherwise.
+ * @param key  Array containing the source phone hash as the only item.
+ * @param keys Expected 1 but ignored.
+ * @param item Connection hash table item.
+ *
+ * @return True on match, false otherwise.
+ *
  */
 static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item)
 {
-	connection_t *hs;
-
-	hs = hash_table_get_instance(item, connection_t, link);
-	
-	return key[0] == hs->in_phone_hash;
+	connection_t *hs = hash_table_get_instance(item, connection_t, link);
+	return (key[0] == hs->in_phone_hash);
 }
 
@@ -239,5 +231,6 @@
  * hash table.
  *
- * @param item		Connection hash table item being removed.
+ * @param item Connection hash table item being removed.
+ *
  */
 static void conn_remove(link_t *item)
@@ -256,21 +249,22 @@
 /** Sort in current fibril's timeout request.
  *
- * @param wd		Wait data of the current fibril.
+ * @param wd Wait data of the current fibril.
+ *
  */
 static void insert_timeout(awaiter_t *wd)
 {
-	link_t *tmp;
-	awaiter_t *cur;
-
-	wd->timedout = 0;
-	wd->inlist = 1;
-
-	tmp = timeout_list.next;
+	wd->timedout = false;
+	wd->inlist = true;
+	
+	link_t *tmp = timeout_list.next;
 	while (tmp != &timeout_list) {
-		cur = list_get_instance(tmp, awaiter_t, link);
+		awaiter_t *cur = list_get_instance(tmp, awaiter_t, link);
+		
 		if (tv_gteq(&cur->expires, &wd->expires))
 			break;
+		
 		tmp = tmp->next;
 	}
+	
 	list_append(&wd->link, tmp);
 }
@@ -282,33 +276,35 @@
  * timeouts are unregistered.
  *
- * @param callid	Hash of the incoming call.
- * @param call		Data of the incoming call.
- *
- * @return		Zero if the call doesn't match any connection.
- * 			One if the call was passed to the respective connection
- * 			fibril.
- */
-static int route_call(ipc_callid_t callid, ipc_call_t *call)
-{
-	connection_t *conn;
-	msg_t *msg;
-	link_t *hlp;
-	unsigned long key;
-
+ * @param callid Hash of the incoming call.
+ * @param call   Data of the incoming call.
+ *
+ * @return False if the call doesn't match any connection.
+ *         True if the call was passed to the respective connection fibril.
+ *
+ */
+static bool route_call(ipc_callid_t callid, ipc_call_t *call)
+{
 	futex_down(&async_futex);
-
-	key = call->in_phone_hash;
-	hlp = hash_table_find(&conn_hash_table, &key);
+	
+	unsigned long key = call->in_phone_hash;
+	link_t *hlp = hash_table_find(&conn_hash_table, &key);
+	
 	if (!hlp) {
 		futex_up(&async_futex);
-		return 0;
-	}
-	conn = hash_table_get_instance(hlp, connection_t, link);
-
-	msg = malloc(sizeof(*msg));
+		return false;
+	}
+	
+	connection_t *conn = hash_table_get_instance(hlp, connection_t, link);
+	
+	msg_t *msg = malloc(sizeof(*msg));
+	if (!msg) {
+		futex_up(&async_futex);
+		return false;
+	}
+	
 	msg->callid = callid;
 	msg->call = *call;
 	list_append(&msg->link, &conn->msg_queue);
-
+	
 	if (IPC_GET_METHOD(*call) == IPC_M_PHONE_HUNGUP)
 		conn->close_callid = callid;
@@ -316,57 +312,108 @@
 	/* If the connection fibril is waiting for an event, activate it */
 	if (!conn->wdata.active) {
+		
 		/* If in timeout list, remove it */
 		if (conn->wdata.inlist) {
-			conn->wdata.inlist = 0;
+			conn->wdata.inlist = false;
 			list_remove(&conn->wdata.link);
 		}
-		conn->wdata.active = 1;
+		
+		conn->wdata.active = true;
 		fibril_add_ready(conn->wdata.fid);
 	}
-
+	
 	futex_up(&async_futex);
-
-	return 1;
+	return true;
+}
+
+/** Notification fibril.
+ *
+ * When a notification arrives, a fibril with this implementing function is
+ * created. It calls interrupt_received() and does the final cleanup.
+ *
+ * @param arg Message structure pointer.
+ *
+ * @return Always zero.
+ *
+ */
+static int notification_fibril(void *arg)
+{
+	msg_t *msg = (msg_t *) arg;
+	interrupt_received(msg->callid, &msg->call);
+	
+	free(msg);
+	return 0;
+}
+
+/** Process interrupt notification.
+ *
+ * A new fibril is created which would process the notification.
+ *
+ * @param callid Hash of the incoming call.
+ * @param call   Data of the incoming call.
+ *
+ * @return False if an error occured.
+ *         True if the call was passed to the notification fibril.
+ *
+ */
+static bool process_notification(ipc_callid_t callid, ipc_call_t *call)
+{
+	futex_down(&async_futex);
+	
+	msg_t *msg = malloc(sizeof(*msg));
+	if (!msg) {
+		futex_up(&async_futex);
+		return false;
+	}
+	
+	msg->callid = callid;
+	msg->call = *call;
+	
+	fid_t fid = fibril_create(notification_fibril, msg);
+	fibril_add_ready(fid);
+	
+	futex_up(&async_futex);
+	return true;
 }
 
 /** Return new incoming message for the current (fibril-local) connection.
  *
- * @param call		Storage where the incoming call data will be stored.
- * @param usecs		Timeout in microseconds. Zero denotes no timeout.
- *
- * @return		If no timeout was specified, then a hash of the
- * 			incoming call is returned. If a timeout is specified,
- * 			then a hash of the incoming call is returned unless
- * 			the timeout expires prior to receiving a message. In
- * 			that case zero is returned.
+ * @param call  Storage where the incoming call data will be stored.
+ * @param usecs Timeout in microseconds. Zero denotes no timeout.
+ *
+ * @return If no timeout was specified, then a hash of the
+ *         incoming call is returned. If a timeout is specified,
+ *         then a hash of the incoming call is returned unless
+ *         the timeout expires prior to receiving a message. In
+ *         that case zero is returned.
+ *
  */
 ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs)
 {
-	msg_t *msg;
-	ipc_callid_t callid;
-	connection_t *conn;
-	
 	assert(FIBRIL_connection);
-	/* GCC 4.1.0 coughs on FIBRIL_connection-> dereference,
+	
+	/* Why doing this?
+	 * GCC 4.1.0 coughs on FIBRIL_connection-> dereference.
 	 * GCC 4.1.1 happilly puts the rdhwr instruction in delay slot.
-	 *           I would never expect to find so many errors in 
-	 *           a compiler *($&$(*&$
+	 *           I would never expect to find so many errors in
+	 *           a compiler.
 	 */
-	conn = FIBRIL_connection; 
-
+	connection_t *conn = FIBRIL_connection;
+	
 	futex_down(&async_futex);
-
+	
 	if (usecs) {
 		gettimeofday(&conn->wdata.expires, NULL);
 		tv_add(&conn->wdata.expires, usecs);
-	} else {
-		conn->wdata.inlist = 0;
-	}
+	} else
+		conn->wdata.inlist = false;
+	
 	/* If nothing in queue, wait until something arrives */
 	while (list_empty(&conn->msg_queue)) {
 		if (usecs)
 			insert_timeout(&conn->wdata);
-
-		conn->wdata.active = 0;
+		
+		conn->wdata.active = false;
+		
 		/*
 		 * Note: the current fibril will be rescheduled either due to a
@@ -376,11 +423,12 @@
 		 */
 		fibril_switch(FIBRIL_TO_MANAGER);
+		
 		/*
-		 * Futex is up after getting back from async_manager get it
-		 * again.
+		 * Futex is up after getting back from async_manager.
+		 * Get it again.
 		 */
 		futex_down(&async_futex);
-		if (usecs && conn->wdata.timedout &&
-		    list_empty(&conn->msg_queue)) {
+		if ((usecs) && (conn->wdata.timedout)
+		    && (list_empty(&conn->msg_queue))) {
 			/* If we timed out -> exit */
 			futex_up(&async_futex);
@@ -389,7 +437,8 @@
 	}
 	
-	msg = list_get_instance(conn->msg_queue.next, msg_t, link);
+	msg_t *msg = list_get_instance(conn->msg_queue.next, msg_t, link);
 	list_remove(&msg->link);
-	callid = msg->callid;
+	
+	ipc_callid_t callid = msg->callid;
 	*call = msg->call;
 	free(msg);
@@ -403,6 +452,7 @@
  * This function is defined as a weak symbol - to be redefined in user code.
  *
- * @param callid	Hash of the incoming call.
- * @param call		Data of the incoming call.
+ * @param callid Hash of the incoming call.
+ * @param call   Data of the incoming call.
+ *
  */
 static void default_client_connection(ipc_callid_t callid, ipc_call_t *call)
@@ -413,6 +463,9 @@
 /** Default fibril function that gets called to handle interrupt notifications.
  *
- * @param callid	Hash of the incoming call.
- * @param call		Data of the incoming call.
+ * This function is defined as a weak symbol - to be redefined in user code.
+ *
+ * @param callid Hash of the incoming call.
+ * @param call   Data of the incoming call.
+ *
  */
 static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call)
@@ -425,15 +478,15 @@
  * created. It calls client_connection() and does the final cleanup.
  *
- * @param arg		Connection structure pointer.
- *
- * @return		Always zero.
- */
-static int connection_fibril(void  *arg)
-{
-	unsigned long key;
-	msg_t *msg;
-	int close_answered = 0;
-
-	/* Setup fibril-local connection pointer */
+ * @param arg Connection structure pointer.
+ *
+ * @return Always zero.
+ *
+ */
+static int connection_fibril(void *arg)
+{
+	/*
+	 * Setup fibril-local connection pointer and call client_connection().
+	 *
+	 */
 	FIBRIL_connection = (connection_t *) arg;
 	FIBRIL_connection->cfibril(FIBRIL_connection->callid,
@@ -442,5 +495,5 @@
 	/* Remove myself from the connection hash table */
 	futex_down(&async_futex);
-	key = FIBRIL_connection->in_phone_hash;
+	unsigned long key = FIBRIL_connection->in_phone_hash;
 	hash_table_remove(&conn_hash_table, &key, 1);
 	futex_up(&async_futex);
@@ -448,12 +501,12 @@
 	/* Answer all remaining messages with EHANGUP */
 	while (!list_empty(&FIBRIL_connection->msg_queue)) {
-		msg = list_get_instance(FIBRIL_connection->msg_queue.next,
-		    msg_t, link);
+		msg_t *msg
+		    = list_get_instance(FIBRIL_connection->msg_queue.next, msg_t, link);
+		
 		list_remove(&msg->link);
-		if (msg->callid == FIBRIL_connection->close_callid)
-			close_answered = 1;
 		ipc_answer_0(msg->callid, EHANGUP);
 		free(msg);
 	}
+	
 	if (FIBRIL_connection->close_callid)
 		ipc_answer_0(FIBRIL_connection->close_callid, EOK);
@@ -464,26 +517,24 @@
 /** Create a new fibril for a new connection.
  *
- * Creates new fibril for connection, fills in connection structures and inserts
+ * Create new fibril for connection, fill in connection structures and inserts
  * it into the hash table, so that later we can easily do routing of messages to
  * particular fibrils.
  *
- * @param in_phone_hash	Identification of the incoming connection.
- * @param callid	Hash of the opening IPC_M_CONNECT_ME_TO call.
- * 			If callid is zero, the connection was opened by
- * 			accepting the IPC_M_CONNECT_TO_ME call and this function
- * 			is called directly by the server.
- * @param call		Call data of the opening call.
- * @param cfibril	Fibril function that should be called upon opening the
- * 			connection.
- *
- * @return 		New fibril id or NULL on failure.
+ * @param in_phone_hash Identification of the incoming connection.
+ * @param callid        Hash of the opening IPC_M_CONNECT_ME_TO call.
+ *                      If callid is zero, the connection was opened by
+ *                      accepting the IPC_M_CONNECT_TO_ME call and this function
+ *                      is called directly by the server.
+ * @param call          Call data of the opening call.
+ * @param cfibril       Fibril function that should be called upon opening the
+ *                      connection.
+ *
+ * @return New fibril id or NULL on failure.
+ *
  */
 fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid,
     ipc_call_t *call, void (*cfibril)(ipc_callid_t, ipc_call_t *))
 {
-	connection_t *conn;
-	unsigned long key;
-	
-	conn = malloc(sizeof(*conn));
+	connection_t *conn = malloc(sizeof(*conn));
 	if (!conn) {
 		if (callid)
@@ -491,14 +542,18 @@
 		return NULL;
 	}
+	
 	conn->in_phone_hash = in_phone_hash;
 	list_initialize(&conn->msg_queue);
 	conn->callid = callid;
-	conn->close_callid = 0;
+	conn->close_callid = false;
+	
 	if (call)
 		conn->call = *call;
-	conn->wdata.active = 1;	/* We will activate the fibril ASAP */
+	
+	/* We will activate the fibril ASAP */
+	conn->wdata.active = true;
 	conn->cfibril = cfibril;
-	
 	conn->wdata.fid = fibril_create(connection_fibril, conn);
+	
 	if (!conn->wdata.fid) {
 		free(conn);
@@ -509,5 +564,6 @@
 	
 	/* Add connection to the connection hash table */
-	key = conn->in_phone_hash;
+	ipcarg_t key = conn->in_phone_hash;
+	
 	futex_down(&async_futex);
 	hash_table_insert(&conn_hash_table, &key, &conn->link);
@@ -524,6 +580,6 @@
  * Otherwise the call is routed to its connection fibril.
  *
- * @param callid	Hash of the incoming call.
- * @param call		Data of the incoming call.
+ * @param callid Hash of the incoming call.
+ * @param call   Data of the incoming call.
  *
  */
@@ -532,7 +588,5 @@
 	/* Unrouted call - do some default behaviour */
 	if ((callid & IPC_CALLID_NOTIFICATION)) {
-		_in_interrupt_handler = 1;
-		(*interrupt_received)(callid, call);
-		_in_interrupt_handler = 0;
+		process_notification(callid, call);
 		return;
 	}
@@ -558,29 +612,31 @@
 {
 	struct timeval tv;
-	awaiter_t *waiter;
-	link_t *cur;
-
 	gettimeofday(&tv, NULL);
+	
 	futex_down(&async_futex);
-
-	cur = timeout_list.next;
+	
+	link_t *cur = timeout_list.next;
 	while (cur != &timeout_list) {
-		waiter = list_get_instance(cur, awaiter_t, link);
+		awaiter_t *waiter = list_get_instance(cur, awaiter_t, link);
+		
 		if (tv_gt(&waiter->expires, &tv))
 			break;
+		
 		cur = cur->next;
+		
 		list_remove(&waiter->link);
-		waiter->inlist = 0;
-		waiter->timedout = 1;
+		waiter->inlist = false;
+		waiter->timedout = true;
+		
 		/*
- 		 * Redundant condition?
- 		 * The fibril should not be active when it gets here.
+		 * Redundant condition?
+		 * The fibril should not be active when it gets here.
 		 */
 		if (!waiter->active) {
-			waiter->active = 1;
+			waiter->active = true;
 			fibril_add_ready(waiter->fid);
 		}
 	}
-
+	
 	futex_up(&async_futex);
 }
@@ -588,15 +644,10 @@
 /** Endless loop dispatching incoming calls and answers.
  *
- * @return		Never returns.
+ * @return Never returns.
+ *
  */
 static int async_manager_worker(void)
 {
-	ipc_call_t call;
-	ipc_callid_t callid;
-	int timeout;
-	awaiter_t *waiter;
-	struct timeval tv;
-
-	while (1) {
+	while (true) {
 		if (fibril_switch(FIBRIL_FROM_MANAGER)) {
 			futex_up(&async_futex); 
@@ -607,9 +658,15 @@
 			continue;
 		}
+		
 		futex_down(&async_futex);
+		
+		suseconds_t timeout;
 		if (!list_empty(&timeout_list)) {
-			waiter = list_get_instance(timeout_list.next, awaiter_t,
-			    link);
+			awaiter_t *waiter
+			    = list_get_instance(timeout_list.next, awaiter_t, link);
+			
+			struct timeval tv;
 			gettimeofday(&tv, NULL);
+			
 			if (tv_gteq(&tv, &waiter->expires)) {
 				futex_up(&async_futex);
@@ -620,17 +677,19 @@
 		} else
 			timeout = SYNCH_NO_TIMEOUT;
+		
 		futex_up(&async_futex);
-
-		callid = ipc_wait_cycle(&call, timeout, SYNCH_FLAGS_NONE);
-
+		
+		ipc_call_t call;
+		ipc_callid_t callid
+		    = ipc_wait_cycle(&call, timeout, SYNCH_FLAGS_NONE);
+		
 		if (!callid) {
 			handle_expired_timeouts();
 			continue;
 		}
-
-		if (callid & IPC_CALLID_ANSWERED) {
+		
+		if (callid & IPC_CALLID_ANSWERED)
 			continue;
-		}
-
+		
 		handle_call(callid, &call);
 	}
@@ -640,14 +699,15 @@
 
 /** Function to start async_manager as a standalone fibril.
- * 
+ *
  * When more kernel threads are used, one async manager should exist per thread.
  *
- * @param arg		Unused.
- *
- * @return		Never returns.
+ * @param arg Unused.
+ * @return Never returns.
+ *
  */
 static int async_manager_fibril(void *arg)
 {
 	futex_up(&async_futex);
+	
 	/*
 	 * async_futex is always locked when entering manager
@@ -661,7 +721,5 @@
 void async_create_manager(void)
 {
-	fid_t fid;
-
-	fid = fibril_create(async_manager_fibril, NULL);
+	fid_t fid = fibril_create(async_manager_fibril, NULL);
 	fibril_add_manager(fid);
 }
@@ -675,5 +733,5 @@
 /** Initialize the async framework.
  *
- * @return		Zero on success or an error code.
+ * @return Zero on success or an error code.
  */
 int _async_init(void)
@@ -695,28 +753,31 @@
  * Notify the fibril which is waiting for this message that it has arrived.
  *
- * @param private	Pointer to the asynchronous message record.
- * @param retval	Value returned in the answer.
- * @param data		Call data of the answer.
- */
-static void reply_received(void *private, int retval, ipc_call_t *data)
-{
-	amsg_t *msg = (amsg_t *) private;
-
+ * @param arg    Pointer to the asynchronous message record.
+ * @param retval Value returned in the answer.
+ * @param data   Call data of the answer.
+ */
+static void reply_received(void *arg, int retval, ipc_call_t *data)
+{
+	amsg_t *msg = (amsg_t *) arg;
 	msg->retval = retval;
-
+	
 	futex_down(&async_futex);
+	
 	/* Copy data after futex_down, just in case the call was detached */
 	if (msg->dataptr)
-		*msg->dataptr = *data; 
-
+		*msg->dataptr = *data;
+	
 	write_barrier();
+	
 	/* Remove message from timeout list */
 	if (msg->wdata.inlist)
 		list_remove(&msg->wdata.link);
-	msg->done = 1;
+	
+	msg->done = true;
 	if (!msg->wdata.active) {
-		msg->wdata.active = 1;
+		msg->wdata.active = true;
 		fibril_add_ready(msg->wdata.fid);
 	}
+	
 	futex_up(&async_futex);
 }
@@ -727,29 +788,32 @@
  * completion.
  *
- * @param phoneid	Handle of the phone that will be used for the send.
- * @param method	Service-defined method.
- * @param arg1		Service-defined payload argument.
- * @param arg2		Service-defined payload argument.
- * @param arg3		Service-defined payload argument.
- * @param arg4		Service-defined payload argument.
- * @param dataptr	If non-NULL, storage where the reply data will be
- * 			stored.
- *
- * @return		Hash of the sent message.
+ * @param phoneid Handle of the phone that will be used for the send.
+ * @param method  Service-defined method.
+ * @param arg1    Service-defined payload argument.
+ * @param arg2    Service-defined payload argument.
+ * @param arg3    Service-defined payload argument.
+ * @param arg4    Service-defined payload argument.
+ * @param dataptr If non-NULL, storage where the reply data will be
+ *                stored.
+ *
+ * @return Hash of the sent message or 0 on error.
+ *
  */
 aid_t async_send_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr)
 {
-	amsg_t *msg;
-	
-	msg = malloc(sizeof(*msg));
-	msg->done = 0;
+	amsg_t *msg = malloc(sizeof(*msg));
+	
+	if (!msg)
+		return 0;
+	
+	msg->done = false;
 	msg->dataptr = dataptr;
 	
 	/* We may sleep in the next method, but it will use its own mechanism */
-	msg->wdata.active = 1; 
-				
+	msg->wdata.active = true;
+	
 	ipc_call_async_4(phoneid, method, arg1, arg2, arg3, arg4, msg,
-	    reply_received, !_in_interrupt_handler);
+	    reply_received, true);
 	
 	return (aid_t) msg;
@@ -761,15 +825,16 @@
  * completion.
  *
- * @param phoneid	Handle of the phone that will be used for the send.
- * @param method	Service-defined method.
- * @param arg1		Service-defined payload argument.
- * @param arg2		Service-defined payload argument.
- * @param arg3		Service-defined payload argument.
- * @param arg4		Service-defined payload argument.
- * @param arg5		Service-defined payload argument.
- * @param dataptr	If non-NULL, storage where the reply data will be
- * 			stored.
- *
- * @return		Hash of the sent message.
+ * @param phoneid Handle of the phone that will be used for the send.
+ * @param method  Service-defined method.
+ * @param arg1    Service-defined payload argument.
+ * @param arg2    Service-defined payload argument.
+ * @param arg3    Service-defined payload argument.
+ * @param arg4    Service-defined payload argument.
+ * @param arg5    Service-defined payload argument.
+ * @param dataptr If non-NULL, storage where the reply data will be
+ *                stored.
+ *
+ * @return Hash of the sent message or 0 on error.
+ *
  */
 aid_t async_send_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
@@ -777,15 +842,17 @@
     ipc_call_t *dataptr)
 {
-	amsg_t *msg;
-	
-	msg = malloc(sizeof(*msg));
-	msg->done = 0;
+	amsg_t *msg = malloc(sizeof(*msg));
+	
+	if (!msg)
+		return 0;
+	
+	msg->done = false;
 	msg->dataptr = dataptr;
 	
 	/* We may sleep in next method, but it will use its own mechanism */
-	msg->wdata.active = 1; 
+	msg->wdata.active = true;
 	
 	ipc_call_async_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, msg,
-	    reply_received, !_in_interrupt_handler);
+	    reply_received, true);
 	
 	return (aid_t) msg;
@@ -794,12 +861,13 @@
 /** Wait for a message sent by the async framework.
  *
- * @param amsgid	Hash of the message to wait for.
- * @param retval	Pointer to storage where the retval of the answer will
- * 			be stored.
+ * @param amsgid Hash of the message to wait for.
+ * @param retval Pointer to storage where the retval of the answer will
+ *               be stored.
+ *
  */
 void async_wait_for(aid_t amsgid, ipcarg_t *retval)
 {
 	amsg_t *msg = (amsg_t *) amsgid;
-
+	
 	futex_down(&async_futex);
 	if (msg->done) {
@@ -807,14 +875,18 @@
 		goto done;
 	}
-
+	
 	msg->wdata.fid = fibril_get_id();
-	msg->wdata.active = 0;
-	msg->wdata.inlist = 0;
+	msg->wdata.active = false;
+	msg->wdata.inlist = false;
+	
 	/* Leave the async_futex locked when entering this function */
 	fibril_switch(FIBRIL_TO_MANAGER);
-	/* futex is up automatically after fibril_switch...*/
+	
+	/* Futex is up automatically after fibril_switch */
+	
 done:
 	if (retval)
 		*retval = msg->retval;
+	
 	free(msg);
 }
@@ -822,19 +894,20 @@
 /** Wait for a message sent by the async framework, timeout variant.
  *
- * @param amsgid	Hash of the message to wait for.
- * @param retval	Pointer to storage where the retval of the answer will
- * 			be stored.
- * @param timeout	Timeout in microseconds.
- *
- * @return		Zero on success, ETIMEOUT if the timeout has expired.
+ * @param amsgid  Hash of the message to wait for.
+ * @param retval  Pointer to storage where the retval of the answer will
+ *                be stored.
+ * @param timeout Timeout in microseconds.
+ *
+ * @return Zero on success, ETIMEOUT if the timeout has expired.
+ *
  */
 int async_wait_timeout(aid_t amsgid, ipcarg_t *retval, suseconds_t timeout)
 {
 	amsg_t *msg = (amsg_t *) amsgid;
-
+	
 	/* TODO: Let it go through the event read at least once */
 	if (timeout < 0)
 		return ETIMEOUT;
-
+	
 	futex_down(&async_futex);
 	if (msg->done) {
@@ -842,24 +915,26 @@
 		goto done;
 	}
-
+	
 	gettimeofday(&msg->wdata.expires, NULL);
 	tv_add(&msg->wdata.expires, timeout);
-
+	
 	msg->wdata.fid = fibril_get_id();
-	msg->wdata.active = 0;
+	msg->wdata.active = false;
 	insert_timeout(&msg->wdata);
-
+	
 	/* Leave the async_futex locked when entering this function */
 	fibril_switch(FIBRIL_TO_MANAGER);
-	/* futex is up automatically after fibril_switch...*/
-
+	
+	/* Futex is up automatically after fibril_switch */
+	
 	if (!msg->done)
 		return ETIMEOUT;
-
+	
 done:
 	if (retval)
 		*retval = msg->retval;
+	
 	free(msg);
-
+	
 	return 0;
 }
@@ -869,16 +944,16 @@
  * The current fibril is suspended but the thread continues to execute.
  *
- * @param timeout	Duration of the wait in microseconds.
+ * @param timeout Duration of the wait in microseconds.
+ *
  */
 void async_usleep(suseconds_t timeout)
 {
-	amsg_t *msg;
-	
-	msg = malloc(sizeof(*msg));
+	amsg_t *msg = malloc(sizeof(*msg));
+	
 	if (!msg)
 		return;
 	
 	msg->wdata.fid = fibril_get_id();
-	msg->wdata.active = 0;
+	msg->wdata.active = false;
 	
 	gettimeofday(&msg->wdata.expires, NULL);
@@ -886,8 +961,12 @@
 	
 	futex_down(&async_futex);
+	
 	insert_timeout(&msg->wdata);
+	
 	/* Leave the async_futex locked when entering this function */
 	fibril_switch(FIBRIL_TO_MANAGER);
-	/* futex is up automatically after fibril_switch()...*/
+	
+	/* Futex is up automatically after fibril_switch() */
+	
 	free(msg);
 }
@@ -895,5 +974,6 @@
 /** Setter for client_connection function pointer.
  *
- * @param conn		Function that will implement a new connection fibril.
+ * @param conn Function that will implement a new connection fibril.
+ *
  */
 void async_set_client_connection(async_client_conn_t conn)
@@ -904,10 +984,10 @@
 /** Setter for interrupt_received function pointer.
  *
- * @param conn		Function that will implement a new interrupt
- *			notification fibril.
- */
-void async_set_interrupt_received(async_client_conn_t conn)
-{
-	interrupt_received = conn;
+ * @param intr Function that will implement a new interrupt
+ *             notification fibril.
+ */
+void async_set_interrupt_received(async_client_conn_t intr)
+{
+	interrupt_received = intr;
 }
 
@@ -919,16 +999,18 @@
  * transferring more arguments, see the slower async_req_slow().
  *
- * @param phoneid	Hash of the phone through which to make the call.
- * @param method	Method of the call.
- * @param arg1		Service-defined payload argument.
- * @param arg2		Service-defined payload argument.
- * @param arg3		Service-defined payload argument.
- * @param arg4		Service-defined payload argument.
- * @param r1		If non-NULL, storage for the 1st reply argument.
- * @param r2		If non-NULL, storage for the 2nd reply argument.
- * @param r3		If non-NULL, storage for the 3rd reply argument.
- * @param r4		If non-NULL, storage for the 4th reply argument.
- * @param r5		If non-NULL, storage for the 5th reply argument.
- * @return		Return code of the reply or a negative error code. 
+ * @param phoneid Hash of the phone through which to make the call.
+ * @param method  Method of the call.
+ * @param arg1    Service-defined payload argument.
+ * @param arg2    Service-defined payload argument.
+ * @param arg3    Service-defined payload argument.
+ * @param arg4    Service-defined payload argument.
+ * @param r1      If non-NULL, storage for the 1st reply argument.
+ * @param r2      If non-NULL, storage for the 2nd reply argument.
+ * @param r3      If non-NULL, storage for the 3rd reply argument.
+ * @param r4      If non-NULL, storage for the 4th reply argument.
+ * @param r5      If non-NULL, storage for the 5th reply argument.
+ *
+ * @return Return code of the reply or a negative error code.
+ *
  */
 ipcarg_t async_req_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
@@ -937,19 +1019,25 @@
 {
 	ipc_call_t result;
-	ipcarg_t rc;
-
 	aid_t eid = async_send_4(phoneid, method, arg1, arg2, arg3, arg4,
 	    &result);
+	
+	ipcarg_t rc;
 	async_wait_for(eid, &rc);
-	if (r1) 
+	
+	if (r1)
 		*r1 = IPC_GET_ARG1(result);
+	
 	if (r2)
 		*r2 = IPC_GET_ARG2(result);
+	
 	if (r3)
 		*r3 = IPC_GET_ARG3(result);
+	
 	if (r4)
 		*r4 = IPC_GET_ARG4(result);
+	
 	if (r5)
 		*r5 = IPC_GET_ARG5(result);
+	
 	return rc;
 }
@@ -959,17 +1047,19 @@
  * Send message asynchronously and return only after the reply arrives.
  *
- * @param phoneid	Hash of the phone through which to make the call.
- * @param method	Method of the call.
- * @param arg1		Service-defined payload argument.
- * @param arg2		Service-defined payload argument.
- * @param arg3		Service-defined payload argument.
- * @param arg4		Service-defined payload argument.
- * @param arg5		Service-defined payload argument.
- * @param r1		If non-NULL, storage for the 1st reply argument.
- * @param r2		If non-NULL, storage for the 2nd reply argument.
- * @param r3		If non-NULL, storage for the 3rd reply argument.
- * @param r4		If non-NULL, storage for the 4th reply argument.
- * @param r5		If non-NULL, storage for the 5th reply argument.
- * @return		Return code of the reply or a negative error code. 
+ * @param phoneid Hash of the phone through which to make the call.
+ * @param method  Method of the call.
+ * @param arg1    Service-defined payload argument.
+ * @param arg2    Service-defined payload argument.
+ * @param arg3    Service-defined payload argument.
+ * @param arg4    Service-defined payload argument.
+ * @param arg5    Service-defined payload argument.
+ * @param r1      If non-NULL, storage for the 1st reply argument.
+ * @param r2      If non-NULL, storage for the 2nd reply argument.
+ * @param r3      If non-NULL, storage for the 3rd reply argument.
+ * @param r4      If non-NULL, storage for the 4th reply argument.
+ * @param r5      If non-NULL, storage for the 5th reply argument.
+ *
+ * @return Return code of the reply or a negative error code.
+ *
  */
 ipcarg_t async_req_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
@@ -978,19 +1068,25 @@
 {
 	ipc_call_t result;
-	ipcarg_t rc;
-
 	aid_t eid = async_send_5(phoneid, method, arg1, arg2, arg3, arg4, arg5,
 	    &result);
+	
+	ipcarg_t rc;
 	async_wait_for(eid, &rc);
-	if (r1) 
+	
+	if (r1)
 		*r1 = IPC_GET_ARG1(result);
+	
 	if (r2)
 		*r2 = IPC_GET_ARG2(result);
+	
 	if (r3)
 		*r3 = IPC_GET_ARG3(result);
+	
 	if (r4)
 		*r4 = IPC_GET_ARG4(result);
+	
 	if (r5)
 		*r5 = IPC_GET_ARG5(result);
+	
 	return rc;
 }
