Index: kernel/generic/src/mm/as.c
===================================================================
--- kernel/generic/src/mm/as.c	(revision c96452180f7af3adf60e8b6f88ac2ad6ec1683e6)
+++ kernel/generic/src/mm/as.c	(revision da1bafb8cf9a3b3be8ef21bc114daaa476a85190)
@@ -33,5 +33,5 @@
 /**
  * @file
- * @brief	Address space related functions.
+ * @brief Address space related functions.
  *
  * This file contains address space manipulation functions.
@@ -86,4 +86,5 @@
  * Each architecture decides what functions will be used to carry out
  * address space operations such as creating or locking page tables.
+ *
  */
 as_operations_t *as_operations = NULL;
@@ -91,4 +92,5 @@
 /**
  * Slab for as_t objects.
+ *
  */
 static slab_cache_t *as_slab;
@@ -100,4 +102,5 @@
  * - as->asid for each as of the as_t type
  * - asids_allocated counter
+ *
  */
 SPINLOCK_INITIALIZE(asidlock);
@@ -106,4 +109,5 @@
  * This list contains address spaces that are not active on any
  * processor and that have valid ASID.
+ *
  */
 LIST_INITIALIZE(inactive_as_with_asid_head);
@@ -112,26 +116,24 @@
 as_t *AS_KERNEL = NULL;
 
-static int area_flags_to_page_flags(int);
+static unsigned int area_flags_to_page_flags(unsigned int);
 static as_area_t *find_area_and_lock(as_t *, uintptr_t);
 static bool check_area_conflicts(as_t *, uintptr_t, size_t, as_area_t *);
 static void sh_info_remove_reference(share_info_t *);
 
-static int as_constructor(void *obj, int flags)
+static int as_constructor(void *obj, unsigned int flags)
 {
 	as_t *as = (as_t *) obj;
-	int rc;
-
+	
 	link_initialize(&as->inactive_as_with_asid_link);
 	mutex_initialize(&as->lock, MUTEX_PASSIVE);
 	
-	rc = as_constructor_arch(as, flags);
+	int rc = as_constructor_arch(as, flags);
 	
 	return rc;
 }
 
-static int as_destructor(void *obj)
+static size_t as_destructor(void *obj)
 {
 	as_t *as = (as_t *) obj;
-
 	return as_destructor_arch(as);
 }
@@ -141,5 +143,5 @@
 {
 	as_arch_init();
-
+	
 	as_slab = slab_cache_create("as_slab", sizeof(as_t), 0,
 	    as_constructor, as_destructor, SLAB_CACHE_MAGDEFERRED);
@@ -157,12 +159,11 @@
 /** Create address space.
  *
- * @param flags		Flags that influence the way in wich the address space
- * 			is created.
- */
-as_t *as_create(int flags)
-{
-	as_t *as;
-
-	as = (as_t *) slab_alloc(as_slab, 0);
+ * @param flags Flags that influence the way in wich the address
+ *              space is created.
+ *
+ */
+as_t *as_create(unsigned int flags)
+{
+	as_t *as = (as_t *) slab_alloc(as_slab, 0);
 	(void) as_create_arch(as, 0);
 	
@@ -176,4 +177,5 @@
 	atomic_set(&as->refcount, 0);
 	as->cpu_refcount = 0;
+	
 #ifdef AS_PAGE_TABLE
 	as->genarch.page_table = page_table_create(flags);
@@ -192,10 +194,9 @@
  * We know that we don't hold any spinlock.
  *
- * @param as		Address space to be destroyed.
+ * @param as Address space to be destroyed.
+ *
  */
 void as_destroy(as_t *as)
 {
-	ipl_t ipl;
-	bool cond;
 	DEADLOCK_PROBE_INIT(p_asidlock);
 
@@ -214,7 +215,9 @@
 	 * disabled to prevent nested context switches. We also depend on the
 	 * fact that so far no spinlocks are held.
+	 *
 	 */
 	preemption_disable();
-	ipl = interrupts_read();
+	ipl_t ipl = interrupts_read();
+	
 retry:
 	interrupts_disable();
@@ -224,30 +227,37 @@
 		goto retry;
 	}
-	preemption_enable();	/* Interrupts disabled, enable preemption */
-	if (as->asid != ASID_INVALID && as != AS_KERNEL) {
+	
+	/* Interrupts disabled, enable preemption */
+	preemption_enable();
+	
+	if ((as->asid != ASID_INVALID) && (as != AS_KERNEL)) {
 		if (as->cpu_refcount == 0)
 			list_remove(&as->inactive_as_with_asid_link);
+		
 		asid_put(as->asid);
 	}
+	
 	spinlock_unlock(&asidlock);
-
+	
 	/*
 	 * Destroy address space areas of the address space.
 	 * The B+tree must be walked carefully because it is
 	 * also being destroyed.
-	 */	
-	for (cond = true; cond; ) {
-		btree_node_t *node;
-
+	 *
+	 */
+	bool cond = true;
+	while (cond) {
 		ASSERT(!list_empty(&as->as_area_btree.leaf_head));
-		node = list_get_instance(as->as_area_btree.leaf_head.next,
+		
+		btree_node_t *node =
+		    list_get_instance(as->as_area_btree.leaf_head.next,
 		    btree_node_t, leaf_link);
-
-		if ((cond = node->keys)) {
+		
+		if ((cond = node->keys))
 			as_area_destroy(as, node->key[0]);
-		}
-	}
-
+	}
+	
 	btree_destroy(&as->as_area_btree);
+	
 #ifdef AS_PAGE_TABLE
 	page_table_destroy(as->genarch.page_table);
@@ -255,7 +265,7 @@
 	page_table_destroy(NULL);
 #endif
-
+	
 	interrupts_restore(ipl);
-
+	
 	slab_free(as_slab, as);
 }
@@ -266,5 +276,6 @@
  * space.
  *
- * @param a		Address space to be held.
+ * @param as Address space to be held.
+ *
  */
 void as_hold(as_t *as)
@@ -278,5 +289,6 @@
  * space.
  *
- * @param a		Address space to be released.
+ * @param asAddress space to be released.
+ *
  */
 void as_release(as_t *as)
@@ -290,32 +302,30 @@
  * The created address space area is added to the target address space.
  *
- * @param as		Target address space.
- * @param flags		Flags of the area memory.
- * @param size		Size of area.
- * @param base		Base address of area.
- * @param attrs		Attributes of the area.
- * @param backend	Address space area backend. NULL if no backend is used.
- * @param backend_data	NULL or a pointer to an array holding two void *.
- *
- * @return		Address space area on success or NULL on failure.
- */
-as_area_t *
-as_area_create(as_t *as, int flags, size_t size, uintptr_t base, int attrs,
-    mem_backend_t *backend, mem_backend_data_t *backend_data)
-{
-	ipl_t ipl;
-	as_area_t *a;
-	
+ * @param as           Target address space.
+ * @param flags        Flags of the area memory.
+ * @param size         Size of area.
+ * @param base         Base address of area.
+ * @param attrs        Attributes of the area.
+ * @param backend      Address space area backend. NULL if no backend is used.
+ * @param backend_data NULL or a pointer to an array holding two void *.
+ *
+ * @return Address space area on success or NULL on failure.
+ *
+ */
+as_area_t *as_area_create(as_t *as, unsigned int flags, size_t size,
+    uintptr_t base, unsigned int attrs, mem_backend_t *backend,
+    mem_backend_data_t *backend_data)
+{
 	if (base % PAGE_SIZE)
 		return NULL;
-
+	
 	if (!size)
 		return NULL;
-
+	
 	/* Writeable executable areas are not supported. */
 	if ((flags & AS_AREA_EXEC) && (flags & AS_AREA_WRITE))
 		return NULL;
 	
-	ipl = interrupts_disable();
+	ipl_t ipl = interrupts_disable();
 	mutex_lock(&as->lock);
 	
@@ -326,54 +336,52 @@
 	}
 	
-	a = (as_area_t *) malloc(sizeof(as_area_t), 0);
-
-	mutex_initialize(&a->lock, MUTEX_PASSIVE);
-	
-	a->as = as;
-	a->flags = flags;
-	a->attributes = attrs;
-	a->pages = SIZE2FRAMES(size);
-	a->base = base;
-	a->sh_info = NULL;
-	a->backend = backend;
+	as_area_t *area = (as_area_t *) malloc(sizeof(as_area_t), 0);
+	
+	mutex_initialize(&area->lock, MUTEX_PASSIVE);
+	
+	area->as = as;
+	area->flags = flags;
+	area->attributes = attrs;
+	area->pages = SIZE2FRAMES(size);
+	area->base = base;
+	area->sh_info = NULL;
+	area->backend = backend;
+	
 	if (backend_data)
-		a->backend_data = *backend_data;
+		area->backend_data = *backend_data;
 	else
-		memsetb(&a->backend_data, sizeof(a->backend_data), 0);
-
-	btree_create(&a->used_space);
-	
-	btree_insert(&as->as_area_btree, base, (void *) a, NULL);
-
+		memsetb(&area->backend_data, sizeof(area->backend_data), 0);
+	
+	btree_create(&area->used_space);
+	btree_insert(&as->as_area_btree, base, (void *) area, NULL);
+	
 	mutex_unlock(&as->lock);
 	interrupts_restore(ipl);
-
-	return a;
+	
+	return area;
 }
 
 /** Find address space area and change it.
  *
- * @param as		Address space.
- * @param address	Virtual address belonging to the area to be changed.
- * 			Must be page-aligned.
- * @param size		New size of the virtual memory block starting at
- * 			address. 
- * @param flags		Flags influencing the remap operation. Currently unused.
- *
- * @return		Zero on success or a value from @ref errno.h otherwise.
- */ 
-int as_area_resize(as_t *as, uintptr_t address, size_t size, int flags)
-{
-	as_area_t *area;
-	ipl_t ipl;
-	size_t pages;
-	
-	ipl = interrupts_disable();
+ * @param as      Address space.
+ * @param address Virtual address belonging to the area to be changed.
+ *                Must be page-aligned.
+ * @param size    New size of the virtual memory block starting at
+ *                address.
+ * @param flags   Flags influencing the remap operation. Currently unused.
+ *
+ * @return Zero on success or a value from @ref errno.h otherwise.
+ *
+ */
+int as_area_resize(as_t *as, uintptr_t address, size_t size, unsigned int flags)
+{
+	ipl_t ipl = interrupts_disable();
 	mutex_lock(&as->lock);
 	
 	/*
 	 * Locate the area.
-	 */
-	area = find_area_and_lock(as, address);
+	 *
+	 */
+	as_area_t *area = find_area_and_lock(as, address);
 	if (!area) {
 		mutex_unlock(&as->lock);
@@ -381,9 +389,10 @@
 		return ENOENT;
 	}
-
+	
 	if (area->backend == &phys_backend) {
 		/*
 		 * Remapping of address space areas associated
 		 * with memory mapped devices is not supported.
+		 *
 		 */
 		mutex_unlock(&area->lock);
@@ -392,8 +401,10 @@
 		return ENOTSUP;
 	}
+	
 	if (area->sh_info) {
 		/*
-		 * Remapping of shared address space areas 
+		 * Remapping of shared address space areas
 		 * is not supported.
+		 *
 		 */
 		mutex_unlock(&area->lock);
@@ -402,9 +413,10 @@
 		return ENOTSUP;
 	}
-
-	pages = SIZE2FRAMES((address - area->base) + size);
+	
+	size_t pages = SIZE2FRAMES((address - area->base) + size);
 	if (!pages) {
 		/*
 		 * Zero size address space areas are not allowed.
+		 *
 		 */
 		mutex_unlock(&area->lock);
@@ -415,20 +427,21 @@
 	
 	if (pages < area->pages) {
-		bool cond;
 		uintptr_t start_free = area->base + pages * PAGE_SIZE;
-
+		
 		/*
 		 * Shrinking the area.
 		 * No need to check for overlaps.
-		 */
-
+		 *
+		 */
+		
 		page_table_lock(as, false);
-
+		
 		/*
 		 * Start TLB shootdown sequence.
+		 *
 		 */
 		tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base +
 		    pages * PAGE_SIZE, area->pages - pages);
-
+		
 		/*
 		 * Remove frames belonging to used space starting from
@@ -437,42 +450,46 @@
 		 * is also the right way to remove part of the used_space
 		 * B+tree leaf list.
-		 */		
-		for (cond = true; cond;) {
-			btree_node_t *node;
-		
+		 *
+		 */
+		bool cond = true;
+		while (cond) {
 			ASSERT(!list_empty(&area->used_space.leaf_head));
-			node = 
+			
+			btree_node_t *node =
 			    list_get_instance(area->used_space.leaf_head.prev,
 			    btree_node_t, leaf_link);
+			
 			if ((cond = (bool) node->keys)) {
-				uintptr_t b = node->key[node->keys - 1];
-				size_t c =
+				uintptr_t ptr = node->key[node->keys - 1];
+				size_t size =
 				    (size_t) node->value[node->keys - 1];
-				unsigned int i = 0;
-			
-				if (overlaps(b, c * PAGE_SIZE, area->base,
+				size_t i = 0;
+				
+				if (overlaps(ptr, size * PAGE_SIZE, area->base,
 				    pages * PAGE_SIZE)) {
 					
-					if (b + c * PAGE_SIZE <= start_free) {
+					if (ptr + size * PAGE_SIZE <= start_free) {
 						/*
 						 * The whole interval fits
 						 * completely in the resized
 						 * address space area.
+						 *
 						 */
 						break;
 					}
-		
+					
 					/*
 					 * Part of the interval corresponding
 					 * to b and c overlaps with the resized
 					 * address space area.
+					 *
 					 */
-		
-					cond = false;	/* we are almost done */
-					i = (start_free - b) >> PAGE_WIDTH;
+					
+					/* We are almost done */
+					cond = false;
+					i = (start_free - ptr) >> PAGE_WIDTH;
 					if (!used_space_remove(area, start_free,
-					    c - i))
-						panic("Cannot remove used "
-						    "space.");
+					    size - i))
+						panic("Cannot remove used space.");
 				} else {
 					/*
@@ -480,58 +497,61 @@
 					 * completely removed.
 					 */
-					if (!used_space_remove(area, b, c))
-						panic("Cannot remove used "
-						    "space.");
+					if (!used_space_remove(area, ptr, size))
+						panic("Cannot remove used space.");
 				}
-			
-				for (; i < c; i++) {
-					pte_t *pte;
-			
-					pte = page_mapping_find(as, b +
+				
+				for (; i < size; i++) {
+					pte_t *pte = page_mapping_find(as, ptr +
 					    i * PAGE_SIZE);
-					ASSERT(pte && PTE_VALID(pte) &&
-					    PTE_PRESENT(pte));
-					if (area->backend &&
-					    area->backend->frame_free) {
+					
+					ASSERT(pte);
+					ASSERT(PTE_VALID(pte));
+					ASSERT(PTE_PRESENT(pte));
+					
+					if ((area->backend) &&
+					    (area->backend->frame_free)) {
 						area->backend->frame_free(area,
-						    b + i * PAGE_SIZE,
+						    ptr + i * PAGE_SIZE,
 						    PTE_GET_FRAME(pte));
 					}
-					page_mapping_remove(as, b +
+					
+					page_mapping_remove(as, ptr +
 					    i * PAGE_SIZE);
 				}
 			}
 		}
-
+		
 		/*
 		 * Finish TLB shootdown sequence.
-		 */
-
+		 *
+		 */
+		
 		tlb_invalidate_pages(as->asid, area->base + pages * PAGE_SIZE,
 		    area->pages - pages);
-
+		
 		/*
 		 * Invalidate software translation caches (e.g. TSB on sparc64).
+		 *
 		 */
 		as_invalidate_translation_cache(as, area->base +
 		    pages * PAGE_SIZE, area->pages - pages);
 		tlb_shootdown_finalize();
-
+		
 		page_table_unlock(as, false);
-		
 	} else {
 		/*
 		 * Growing the area.
 		 * Check for overlaps with other address space areas.
+		 *
 		 */
 		if (!check_area_conflicts(as, address, pages * PAGE_SIZE,
 		    area)) {
 			mutex_unlock(&area->lock);
-			mutex_unlock(&as->lock);		
+			mutex_unlock(&as->lock);
 			interrupts_restore(ipl);
 			return EADDRNOTAVAIL;
 		}
-	} 
-
+	}
+	
 	area->pages = pages;
 	
@@ -539,5 +559,5 @@
 	mutex_unlock(&as->lock);
 	interrupts_restore(ipl);
-
+	
 	return 0;
 }
@@ -545,20 +565,16 @@
 /** Destroy address space area.
  *
- * @param as		Address space.
- * @param address	Address within the area to be deleted.
- *
- * @return		Zero on success or a value from @ref errno.h on failure.
+ * @param as      Address space.
+ * @param address Address within the area to be deleted.
+ *
+ * @return Zero on success or a value from @ref errno.h on failure.
+ *
  */
 int as_area_destroy(as_t *as, uintptr_t address)
 {
-	as_area_t *area;
-	uintptr_t base;
-	link_t *cur;
-	ipl_t ipl;
-
-	ipl = interrupts_disable();
+	ipl_t ipl = interrupts_disable();
 	mutex_lock(&as->lock);
-
-	area = find_area_and_lock(as, address);
+	
+	as_area_t *area = find_area_and_lock(as, address);
 	if (!area) {
 		mutex_unlock(&as->lock);
@@ -566,68 +582,75 @@
 		return ENOENT;
 	}
-
-	base = area->base;
-
+	
+	uintptr_t base = area->base;
+	
 	page_table_lock(as, false);
-
+	
 	/*
 	 * Start TLB shootdown sequence.
 	 */
 	tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base, area->pages);
-
+	
 	/*
 	 * Visit only the pages mapped by used_space B+tree.
 	 */
+	link_t *cur;
 	for (cur = area->used_space.leaf_head.next;
 	    cur != &area->used_space.leaf_head; cur = cur->next) {
 		btree_node_t *node;
-		unsigned int i;
+		btree_key_t i;
 		
 		node = list_get_instance(cur, btree_node_t, leaf_link);
 		for (i = 0; i < node->keys; i++) {
-			uintptr_t b = node->key[i];
-			size_t j;
-			pte_t *pte;
+			uintptr_t ptr = node->key[i];
+			size_t size;
 			
-			for (j = 0; j < (size_t) node->value[i]; j++) {
-				pte = page_mapping_find(as, b + j * PAGE_SIZE);
-				ASSERT(pte && PTE_VALID(pte) &&
-				    PTE_PRESENT(pte));
-				if (area->backend &&
-				    area->backend->frame_free) {
-					area->backend->frame_free(area,	b +
-					    j * PAGE_SIZE, PTE_GET_FRAME(pte));
+			for (size = 0; size < (size_t) node->value[i]; size++) {
+				pte_t *pte = page_mapping_find(as, ptr + size * PAGE_SIZE);
+				
+				ASSERT(pte);
+				ASSERT(PTE_VALID(pte));
+				ASSERT(PTE_PRESENT(pte));
+				
+				if ((area->backend) &&
+				    (area->backend->frame_free)) {
+					area->backend->frame_free(area,
+					    ptr + size * PAGE_SIZE, PTE_GET_FRAME(pte));
 				}
-				page_mapping_remove(as, b + j * PAGE_SIZE);				
+				
+				page_mapping_remove(as, ptr + size * PAGE_SIZE);
 			}
 		}
 	}
-
+	
 	/*
 	 * Finish TLB shootdown sequence.
-	 */
-
+	 *
+	 */
+	
 	tlb_invalidate_pages(as->asid, area->base, area->pages);
-
+	
 	/*
 	 * Invalidate potential software translation caches (e.g. TSB on
 	 * sparc64).
+	 *
 	 */
 	as_invalidate_translation_cache(as, area->base, area->pages);
 	tlb_shootdown_finalize();
-
+	
 	page_table_unlock(as, false);
 	
 	btree_destroy(&area->used_space);
-
+	
 	area->attributes |= AS_AREA_ATTR_PARTIAL;
 	
 	if (area->sh_info)
 		sh_info_remove_reference(area->sh_info);
-		
+	
 	mutex_unlock(&area->lock);
-
+	
 	/*
 	 * Remove the empty area from address space.
+	 *
 	 */
 	btree_remove(&as->as_area_btree, base, NULL);
@@ -647,36 +670,31 @@
  * sh_info of the source area. The process of duplicating the
  * mapping is done through the backend share function.
- * 
- * @param src_as	Pointer to source address space.
- * @param src_base	Base address of the source address space area.
- * @param acc_size	Expected size of the source area.
- * @param dst_as	Pointer to destination address space.
- * @param dst_base	Target base address.
+ *
+ * @param src_as         Pointer to source address space.
+ * @param src_base       Base address of the source address space area.
+ * @param acc_size       Expected size of the source area.
+ * @param dst_as         Pointer to destination address space.
+ * @param dst_base       Target base address.
  * @param dst_flags_mask Destination address space area flags mask.
  *
- * @return		Zero on success or ENOENT if there is no such task or if
- * 			there is no such address space area, EPERM if there was
- * 			a problem in accepting the area or ENOMEM if there was a
- * 			problem in allocating destination address space area.
- * 			ENOTSUP is returned if the address space area backend
- * 			does not support sharing.
+ * @return Zero on success.
+ * @return ENOENT if there is no such task or such address space.
+ * @return EPERM if there was a problem in accepting the area.
+ * @return ENOMEM if there was a problem in allocating destination
+ *         address space area.
+ * @return ENOTSUP if the address space area backend does not support
+ *         sharing.
+ *
  */
 int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
-    as_t *dst_as, uintptr_t dst_base, int dst_flags_mask)
-{
-	ipl_t ipl;
-	int src_flags;
-	size_t src_size;
-	as_area_t *src_area, *dst_area;
-	share_info_t *sh_info;
-	mem_backend_t *src_backend;
-	mem_backend_data_t src_backend_data;
-	
-	ipl = interrupts_disable();
+    as_t *dst_as, uintptr_t dst_base, unsigned int dst_flags_mask)
+{
+	ipl_t ipl = interrupts_disable();
 	mutex_lock(&src_as->lock);
-	src_area = find_area_and_lock(src_as, src_base);
+	as_area_t *src_area = find_area_and_lock(src_as, src_base);
 	if (!src_area) {
 		/*
 		 * Could not find the source address space area.
+		 *
 		 */
 		mutex_unlock(&src_as->lock);
@@ -684,9 +702,10 @@
 		return ENOENT;
 	}
-
-	if (!src_area->backend || !src_area->backend->share) {
+	
+	if ((!src_area->backend) || (!src_area->backend->share)) {
 		/*
 		 * There is no backend or the backend does not
 		 * know how to share the area.
+		 *
 		 */
 		mutex_unlock(&src_area->lock);
@@ -696,15 +715,15 @@
 	}
 	
-	src_size = src_area->pages * PAGE_SIZE;
-	src_flags = src_area->flags;
-	src_backend = src_area->backend;
-	src_backend_data = src_area->backend_data;
-
+	size_t src_size = src_area->pages * PAGE_SIZE;
+	unsigned int src_flags = src_area->flags;
+	mem_backend_t *src_backend = src_area->backend;
+	mem_backend_data_t src_backend_data = src_area->backend_data;
+	
 	/* Share the cacheable flag from the original mapping */
 	if (src_flags & AS_AREA_CACHEABLE)
 		dst_flags_mask |= AS_AREA_CACHEABLE;
-
-	if (src_size != acc_size ||
-	    (src_flags & dst_flags_mask) != dst_flags_mask) {
+	
+	if ((src_size != acc_size) ||
+	    ((src_flags & dst_flags_mask) != dst_flags_mask)) {
 		mutex_unlock(&src_area->lock);
 		mutex_unlock(&src_as->lock);
@@ -712,11 +731,12 @@
 		return EPERM;
 	}
-
+	
 	/*
 	 * Now we are committed to sharing the area.
 	 * First, prepare the area for sharing.
 	 * Then it will be safe to unlock it.
-	 */
-	sh_info = src_area->sh_info;
+	 *
+	 */
+	share_info_t *sh_info = src_area->sh_info;
 	if (!sh_info) {
 		sh_info = (share_info_t *) malloc(sizeof(share_info_t), 0);
@@ -725,6 +745,8 @@
 		btree_create(&sh_info->pagemap);
 		src_area->sh_info = sh_info;
+		
 		/*
 		 * Call the backend to setup sharing.
+		 *
 		 */
 		src_area->backend->share(src_area);
@@ -734,8 +756,8 @@
 		mutex_unlock(&sh_info->lock);
 	}
-
+	
 	mutex_unlock(&src_area->lock);
 	mutex_unlock(&src_as->lock);
-
+	
 	/*
 	 * Create copy of the source address space area.
@@ -745,7 +767,8 @@
 	 * The flags of the source area are masked against dst_flags_mask
 	 * to support sharing in less privileged mode.
-	 */
-	dst_area = as_area_create(dst_as, dst_flags_mask, src_size, dst_base,
-	    AS_AREA_ATTR_PARTIAL, src_backend, &src_backend_data);
+	 *
+	 */
+	as_area_t *dst_area = as_area_create(dst_as, dst_flags_mask, src_size,
+	    dst_base, AS_AREA_ATTR_PARTIAL, src_backend, &src_backend_data);
 	if (!dst_area) {
 		/*
@@ -757,17 +780,18 @@
 		return ENOMEM;
 	}
-
+	
 	/*
 	 * Now the destination address space area has been
 	 * fully initialized. Clear the AS_AREA_ATTR_PARTIAL
 	 * attribute and set the sh_info.
-	 */	
-	mutex_lock(&dst_as->lock);	
+	 *
+	 */
+	mutex_lock(&dst_as->lock);
 	mutex_lock(&dst_area->lock);
 	dst_area->attributes &= ~AS_AREA_ATTR_PARTIAL;
 	dst_area->sh_info = sh_info;
 	mutex_unlock(&dst_area->lock);
-	mutex_unlock(&dst_as->lock);	
-
+	mutex_unlock(&dst_as->lock);
+	
 	interrupts_restore(ipl);
 	
@@ -779,9 +803,10 @@
  * The address space area must be locked prior to this call.
  *
- * @param area		Address space area.
- * @param access	Access mode.
- *
- * @return		False if access violates area's permissions, true
- * 			otherwise.
+ * @param area   Address space area.
+ * @param access Access mode.
+ *
+ * @return False if access violates area's permissions, true
+ *         otherwise.
+ *
  */
 bool as_area_check_access(as_area_t *area, pf_access_t access)
@@ -792,5 +817,5 @@
 		[PF_ACCESS_EXEC] = AS_AREA_EXEC
 	};
-
+	
 	if (!(area->flags & flagmap[access]))
 		return false;
@@ -813,21 +838,13 @@
  *
  */
-int as_area_change_flags(as_t *as, int flags, uintptr_t address)
-{
-	as_area_t *area;
-	link_t *cur;
-	ipl_t ipl;
-	int page_flags;
-	uintptr_t *old_frame;
-	size_t frame_idx;
-	size_t used_pages;
-	
+int as_area_change_flags(as_t *as, unsigned int flags, uintptr_t address)
+{
 	/* Flags for the new memory mapping */
-	page_flags = area_flags_to_page_flags(flags);
-
-	ipl = interrupts_disable();
+	unsigned int page_flags = area_flags_to_page_flags(flags);
+	
+	ipl_t ipl = interrupts_disable();
 	mutex_lock(&as->lock);
-
-	area = find_area_and_lock(as, address);
+	
+	as_area_t *area = find_area_and_lock(as, address);
 	if (!area) {
 		mutex_unlock(&as->lock);
@@ -835,5 +852,5 @@
 		return ENOENT;
 	}
-
+	
 	if ((area->sh_info) || (area->backend != &anon_backend)) {
 		/* Copying shared areas not supported yet */
@@ -844,64 +861,70 @@
 		return ENOTSUP;
 	}
-
+	
 	/*
 	 * Compute total number of used pages in the used_space B+tree
-	 */
-	used_pages = 0;
-
+	 *
+	 */
+	size_t used_pages = 0;
+	link_t *cur;
+	
 	for (cur = area->used_space.leaf_head.next;
 	    cur != &area->used_space.leaf_head; cur = cur->next) {
-		btree_node_t *node;
-		unsigned int i;
-		
-		node = list_get_instance(cur, btree_node_t, leaf_link);
-		for (i = 0; i < node->keys; i++) {
+		btree_node_t *node
+		    = list_get_instance(cur, btree_node_t, leaf_link);
+		btree_key_t i;
+		
+		for (i = 0; i < node->keys; i++)
 			used_pages += (size_t) node->value[i];
-		}
-	}
-
+	}
+	
 	/* An array for storing frame numbers */
-	old_frame = malloc(used_pages * sizeof(uintptr_t), 0);
-
+	uintptr_t *old_frame = malloc(used_pages * sizeof(uintptr_t), 0);
+	
 	page_table_lock(as, false);
-
+	
 	/*
 	 * Start TLB shootdown sequence.
+	 *
 	 */
 	tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base, area->pages);
-
+	
 	/*
 	 * Remove used pages from page tables and remember their frame
 	 * numbers.
-	 */
-	frame_idx = 0;
-
+	 *
+	 */
+	size_t frame_idx = 0;
+	
 	for (cur = area->used_space.leaf_head.next;
 	    cur != &area->used_space.leaf_head; cur = cur->next) {
-		btree_node_t *node;
-		unsigned int i;
-		
-		node = list_get_instance(cur, btree_node_t, leaf_link);
+		btree_node_t *node
+		    = list_get_instance(cur, btree_node_t, leaf_link);
+		btree_key_t i;
+		
 		for (i = 0; i < node->keys; i++) {
-			uintptr_t b = node->key[i];
-			size_t j;
-			pte_t *pte;
+			uintptr_t ptr = node->key[i];
+			size_t size;
 			
-			for (j = 0; j < (size_t) node->value[i]; j++) {
-				pte = page_mapping_find(as, b + j * PAGE_SIZE);
-				ASSERT(pte && PTE_VALID(pte) &&
-				    PTE_PRESENT(pte));
+			for (size = 0; size < (size_t) node->value[i]; size++) {
+				pte_t *pte = page_mapping_find(as, ptr + size * PAGE_SIZE);
+				
+				ASSERT(pte);
+				ASSERT(PTE_VALID(pte));
+				ASSERT(PTE_PRESENT(pte));
+				
 				old_frame[frame_idx++] = PTE_GET_FRAME(pte);
-
+				
 				/* Remove old mapping */
-				page_mapping_remove(as, b + j * PAGE_SIZE);
+				page_mapping_remove(as, ptr + size * PAGE_SIZE);
 			}
 		}
 	}
-
+	
 	/*
 	 * Finish TLB shootdown sequence.
-	 */
-
+	 *
+	 */
+	
 	tlb_invalidate_pages(as->asid, area->base, area->pages);
 	
@@ -909,15 +932,16 @@
 	 * Invalidate potential software translation caches (e.g. TSB on
 	 * sparc64).
+	 *
 	 */
 	as_invalidate_translation_cache(as, area->base, area->pages);
 	tlb_shootdown_finalize();
-
+	
 	page_table_unlock(as, false);
-
+	
 	/*
 	 * Set the new flags.
 	 */
 	area->flags = flags;
-
+	
 	/*
 	 * Map pages back in with new flags. This step is kept separate
@@ -926,36 +950,35 @@
 	 */
 	frame_idx = 0;
-
+	
 	for (cur = area->used_space.leaf_head.next;
 	    cur != &area->used_space.leaf_head; cur = cur->next) {
-		btree_node_t *node;
-		unsigned int i;
-		
-		node = list_get_instance(cur, btree_node_t, leaf_link);
+		btree_node_t *node
+		    = list_get_instance(cur, btree_node_t, leaf_link);
+		btree_key_t i;
+		
 		for (i = 0; i < node->keys; i++) {
-			uintptr_t b = node->key[i];
-			size_t j;
+			uintptr_t ptr = node->key[i];
+			size_t size;
 			
-			for (j = 0; j < (size_t) node->value[i]; j++) {
+			for (size = 0; size < (size_t) node->value[i]; size++) {
 				page_table_lock(as, false);
-
+				
 				/* Insert the new mapping */
-				page_mapping_insert(as, b + j * PAGE_SIZE,
+				page_mapping_insert(as, ptr + size * PAGE_SIZE,
 				    old_frame[frame_idx++], page_flags);
-
+				
 				page_table_unlock(as, false);
 			}
 		}
 	}
-
+	
 	free(old_frame);
-
+	
 	mutex_unlock(&area->lock);
 	mutex_unlock(&as->lock);
 	interrupts_restore(ipl);
-
+	
 	return 0;
 }
-
 
 /** Handle page fault within the current address space.
@@ -967,18 +990,17 @@
  * Interrupts are assumed disabled.
  *
- * @param page		Faulting page.
- * @param access	Access mode that caused the page fault (i.e.
- * 			read/write/exec).
- * @param istate	Pointer to the interrupted state.
- *
- * @return		AS_PF_FAULT on page fault, AS_PF_OK on success or
- * 			AS_PF_DEFER if the fault was caused by copy_to_uspace()
- * 			or copy_from_uspace().
+ * @param page   Faulting page.
+ * @param access Access mode that caused the page fault (i.e.
+ *               read/write/exec).
+ * @param istate Pointer to the interrupted state.
+ *
+ * @return AS_PF_FAULT on page fault.
+ * @return AS_PF_OK on success.
+ * @return AS_PF_DEFER if the fault was caused by copy_to_uspace()
+ *         or copy_from_uspace().
+ *
  */
 int as_page_fault(uintptr_t page, pf_access_t access, istate_t *istate)
 {
-	pte_t *pte;
-	as_area_t *area;
-	
 	if (!THREAD)
 		return AS_PF_FAULT;
@@ -988,14 +1010,15 @@
 	
 	mutex_lock(&AS->lock);
-	area = find_area_and_lock(AS, page);
+	as_area_t *area = find_area_and_lock(AS, page);
 	if (!area) {
 		/*
 		 * No area contained mapping for 'page'.
 		 * Signal page fault to low-level handler.
+		 *
 		 */
 		mutex_unlock(&AS->lock);
 		goto page_fault;
 	}
-
+	
 	if (area->attributes & AS_AREA_ATTR_PARTIAL) {
 		/*
@@ -1005,17 +1028,18 @@
 		mutex_unlock(&area->lock);
 		mutex_unlock(&AS->lock);
-		goto page_fault;		
-	}
-
-	if (!area->backend || !area->backend->page_fault) {
+		goto page_fault;
+	}
+	
+	if ((!area->backend) || (!area->backend->page_fault)) {
 		/*
 		 * The address space area is not backed by any backend
 		 * or the backend cannot handle page faults.
+		 *
 		 */
 		mutex_unlock(&area->lock);
 		mutex_unlock(&AS->lock);
-		goto page_fault;		
-	}
-
+		goto page_fault;
+	}
+	
 	page_table_lock(AS, false);
 	
@@ -1023,5 +1047,7 @@
 	 * To avoid race condition between two page faults on the same address,
 	 * we need to make sure the mapping has not been already inserted.
-	 */
+	 *
+	 */
+	pte_t *pte;
 	if ((pte = page_mapping_find(AS, page))) {
 		if (PTE_PRESENT(pte)) {
@@ -1039,4 +1065,5 @@
 	/*
 	 * Resort to the backend page fault handler.
+	 *
 	 */
 	if (area->backend->page_fault(area, page, access) != AS_PF_OK) {
@@ -1051,5 +1078,5 @@
 	mutex_unlock(&AS->lock);
 	return AS_PF_OK;
-
+	
 page_fault:
 	if (THREAD->in_copy_from_uspace) {
@@ -1064,5 +1091,5 @@
 		return AS_PF_FAULT;
 	}
-
+	
 	return AS_PF_DEFER;
 }
@@ -1076,6 +1103,7 @@
  * When this function is enetered, no spinlocks may be held.
  *
- * @param old		Old address space or NULL.
- * @param new		New address space.
+ * @param old Old address space or NULL.
+ * @param new New address space.
+ *
  */
 void as_switch(as_t *old_as, as_t *new_as)
@@ -1083,12 +1111,14 @@
 	DEADLOCK_PROBE_INIT(p_asidlock);
 	preemption_disable();
+	
 retry:
 	(void) interrupts_disable();
 	if (!spinlock_trylock(&asidlock)) {
-		/* 
+		/*
 		 * Avoid deadlock with TLB shootdown.
 		 * We can enable interrupts here because
 		 * preemption is disabled. We should not be
 		 * holding any other lock.
+		 *
 		 */
 		(void) interrupts_enable();
@@ -1097,11 +1127,12 @@
 	}
 	preemption_enable();
-
+	
 	/*
 	 * First, take care of the old address space.
-	 */	
+	 */
 	if (old_as) {
 		ASSERT(old_as->cpu_refcount);
-		if((--old_as->cpu_refcount == 0) && (old_as != AS_KERNEL)) {
+		
+		if ((--old_as->cpu_refcount == 0) && (old_as != AS_KERNEL)) {
 			/*
 			 * The old address space is no longer active on
@@ -1109,19 +1140,23 @@
 			 * list of inactive address spaces with assigned
 			 * ASID.
+			 *
 			 */
 			ASSERT(old_as->asid != ASID_INVALID);
+			
 			list_append(&old_as->inactive_as_with_asid_link,
 			    &inactive_as_with_asid_head);
 		}
-
+		
 		/*
 		 * Perform architecture-specific tasks when the address space
 		 * is being removed from the CPU.
+		 *
 		 */
 		as_deinstall_arch(old_as);
 	}
-
+	
 	/*
 	 * Second, prepare the new address space.
+	 *
 	 */
 	if ((new_as->cpu_refcount++ == 0) && (new_as != AS_KERNEL)) {
@@ -1131,4 +1166,5 @@
 			new_as->asid = asid_get();
 	}
+	
 #ifdef AS_PAGE_TABLE
 	SET_PTL0_ADDRESS(new_as->genarch.page_table);
@@ -1138,7 +1174,8 @@
 	 * Perform architecture-specific steps.
 	 * (e.g. write ASID to hardware register etc.)
+	 *
 	 */
 	as_install_arch(new_as);
-
+	
 	spinlock_unlock(&asidlock);
 	
@@ -1148,13 +1185,12 @@
 /** Convert address space area flags to page flags.
  *
- * @param aflags	Flags of some address space area.
- *
- * @return		Flags to be passed to page_mapping_insert().
- */
-int area_flags_to_page_flags(int aflags)
-{
-	int flags;
-
-	flags = PAGE_USER | PAGE_PRESENT;
+ * @param aflags Flags of some address space area.
+ *
+ * @return Flags to be passed to page_mapping_insert().
+ *
+ */
+unsigned int area_flags_to_page_flags(unsigned int aflags)
+{
+	unsigned int flags = PAGE_USER | PAGE_PRESENT;
 	
 	if (aflags & AS_AREA_READ)
@@ -1169,5 +1205,5 @@
 	if (aflags & AS_AREA_CACHEABLE)
 		flags |= PAGE_CACHEABLE;
-		
+	
 	return flags;
 }
@@ -1178,11 +1214,12 @@
  * Interrupts must be disabled.
  *
- * @param a		Address space area.
- *
- * @return		Flags to be used in page_mapping_insert().
- */
-int as_area_get_flags(as_area_t *a)
-{
-	return area_flags_to_page_flags(a->flags);
+ * @param area Address space area.
+ *
+ * @return Flags to be used in page_mapping_insert().
+ *
+ */
+unsigned int as_area_get_flags(as_area_t *area)
+{
+	return area_flags_to_page_flags(area->flags);
 }
 
@@ -1192,10 +1229,11 @@
  * table.
  *
- * @param flags		Flags saying whether the page table is for the kernel
- * 			address space.
- *
- * @return		First entry of the page table.
- */
-pte_t *page_table_create(int flags)
+ * @param flags Flags saying whether the page table is for the kernel
+ *              address space.
+ *
+ * @return First entry of the page table.
+ *
+ */
+pte_t *page_table_create(unsigned int flags)
 {
 	ASSERT(as_operations);
@@ -1209,5 +1247,6 @@
  * Destroy page table in architecture specific way.
  *
- * @param page_table	Physical address of PTL0.
+ * @param page_table Physical address of PTL0.
+ *
  */
 void page_table_destroy(pte_t *page_table)
@@ -1223,11 +1262,12 @@
  * This function should be called before any page_mapping_insert(),
  * page_mapping_remove() and page_mapping_find().
- * 
+ *
  * Locking order is such that address space areas must be locked
  * prior to this call. Address space can be locked prior to this
  * call in which case the lock argument is false.
  *
- * @param as		Address space.
- * @param lock		If false, do not attempt to lock as->lock.
+ * @param as   Address space.
+ * @param lock If false, do not attempt to lock as->lock.
+ *
  */
 void page_table_lock(as_t *as, bool lock)
@@ -1241,6 +1281,7 @@
 /** Unlock page table.
  *
- * @param as		Address space.
- * @param unlock	If false, do not attempt to unlock as->lock.
+ * @param as     Address space.
+ * @param unlock If false, do not attempt to unlock as->lock.
+ *
  */
 void page_table_unlock(as_t *as, bool unlock)
@@ -1257,21 +1298,19 @@
  * The address space must be locked and interrupts must be disabled.
  *
- * @param as		Address space.
- * @param va		Virtual address.
- *
- * @return		Locked address space area containing va on success or
- * 			NULL on failure.
+ * @param as Address space.
+ * @param va Virtual address.
+ *
+ * @return Locked address space area containing va on success or
+ *         NULL on failure.
+ *
  */
 as_area_t *find_area_and_lock(as_t *as, uintptr_t va)
 {
-	as_area_t *a;
-	btree_node_t *leaf, *lnode;
-	unsigned int i;
-	
-	a = (as_area_t *) btree_search(&as->as_area_btree, va, &leaf);
-	if (a) {
+	btree_node_t *leaf;
+	as_area_t *area = (as_area_t *) btree_search(&as->as_area_btree, va, &leaf);
+	if (area) {
 		/* va is the base address of an address space area */
-		mutex_lock(&a->lock);
-		return a;
+		mutex_lock(&area->lock);
+		return area;
 	}
 	
@@ -1280,30 +1319,38 @@
 	 * to find out whether this is a miss or va belongs to an address
 	 * space area found there.
+	 *
 	 */
 	
 	/* First, search the leaf node itself. */
+	btree_key_t i;
+	
 	for (i = 0; i < leaf->keys; i++) {
-		a = (as_area_t *) leaf->value[i];
-		mutex_lock(&a->lock);
-		if ((a->base <= va) && (va < a->base + a->pages * PAGE_SIZE)) {
-			return a;
-		}
-		mutex_unlock(&a->lock);
-	}
-
+		area = (as_area_t *) leaf->value[i];
+		
+		mutex_lock(&area->lock);
+		
+		if ((area->base <= va) && (va < area->base + area->pages * PAGE_SIZE))
+			return area;
+		
+		mutex_unlock(&area->lock);
+	}
+	
 	/*
 	 * Second, locate the left neighbour and test its last record.
 	 * Because of its position in the B+tree, it must have base < va.
-	 */
-	lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf);
+	 *
+	 */
+	btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf);
 	if (lnode) {
-		a = (as_area_t *) lnode->value[lnode->keys - 1];
-		mutex_lock(&a->lock);
-		if (va < a->base + a->pages * PAGE_SIZE) {
-			return a;
-		}
-		mutex_unlock(&a->lock);
-	}
-
+		area = (as_area_t *) lnode->value[lnode->keys - 1];
+		
+		mutex_lock(&area->lock);
+		
+		if (va < area->base + area->pages * PAGE_SIZE)
+			return area;
+		
+		mutex_unlock(&area->lock);
+	}
+	
 	return NULL;
 }
@@ -1313,20 +1360,18 @@
  * The address space must be locked and interrupts must be disabled.
  *
- * @param as		Address space.
- * @param va		Starting virtual address of the area being tested.
- * @param size		Size of the area being tested.
- * @param avoid_area	Do not touch this area. 
- *
- * @return		True if there is no conflict, false otherwise.
- */
-bool
-check_area_conflicts(as_t *as, uintptr_t va, size_t size, as_area_t *avoid_area)
-{
-	as_area_t *a;
-	btree_node_t *leaf, *node;
-	unsigned int i;
-	
+ * @param as         Address space.
+ * @param va         Starting virtual address of the area being tested.
+ * @param size       Size of the area being tested.
+ * @param avoid_area Do not touch this area.
+ *
+ * @return True if there is no conflict, false otherwise.
+ *
+ */
+bool check_area_conflicts(as_t *as, uintptr_t va, size_t size,
+    as_area_t *avoid_area)
+{
 	/*
 	 * We don't want any area to have conflicts with NULL page.
+	 *
 	 */
 	if (overlaps(va, size, NULL, PAGE_SIZE))
@@ -1339,57 +1384,73 @@
 	 * record in the left neighbour, the leftmost record in the right
 	 * neighbour and all records in the leaf node itself.
-	 */
-	
-	if ((a = (as_area_t *) btree_search(&as->as_area_btree, va, &leaf))) {
-		if (a != avoid_area)
+	 *
+	 */
+	btree_node_t *leaf;
+	as_area_t *area =
+	    (as_area_t *) btree_search(&as->as_area_btree, va, &leaf);
+	if (area) {
+		if (area != avoid_area)
 			return false;
 	}
 	
 	/* First, check the two border cases. */
-	if ((node = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf))) {
-		a = (as_area_t *) node->value[node->keys - 1];
-		mutex_lock(&a->lock);
-		if (overlaps(va, size, a->base, a->pages * PAGE_SIZE)) {
-			mutex_unlock(&a->lock);
+	btree_node_t *node =
+	    btree_leaf_node_left_neighbour(&as->as_area_btree, leaf);
+	if (node) {
+		area = (as_area_t *) node->value[node->keys - 1];
+		
+		mutex_lock(&area->lock);
+		
+		if (overlaps(va, size, area->base, area->pages * PAGE_SIZE)) {
+			mutex_unlock(&area->lock);
 			return false;
 		}
-		mutex_unlock(&a->lock);
-	}
+		
+		mutex_unlock(&area->lock);
+	}
+	
 	node = btree_leaf_node_right_neighbour(&as->as_area_btree, leaf);
 	if (node) {
-		a = (as_area_t *) node->value[0];
-		mutex_lock(&a->lock);
-		if (overlaps(va, size, a->base, a->pages * PAGE_SIZE)) {
-			mutex_unlock(&a->lock);
+		area = (as_area_t *) node->value[0];
+		
+		mutex_lock(&area->lock);
+		
+		if (overlaps(va, size, area->base, area->pages * PAGE_SIZE)) {
+			mutex_unlock(&area->lock);
 			return false;
 		}
-		mutex_unlock(&a->lock);
+		
+		mutex_unlock(&area->lock);
 	}
 	
 	/* Second, check the leaf node. */
+	btree_key_t i;
 	for (i = 0; i < leaf->keys; i++) {
-		a = (as_area_t *) leaf->value[i];
-	
-		if (a == avoid_area)
+		area = (as_area_t *) leaf->value[i];
+		
+		if (area == avoid_area)
 			continue;
-	
-		mutex_lock(&a->lock);
-		if (overlaps(va, size, a->base, a->pages * PAGE_SIZE)) {
-			mutex_unlock(&a->lock);
+		
+		mutex_lock(&area->lock);
+		
+		if (overlaps(va, size, area->base, area->pages * PAGE_SIZE)) {
+			mutex_unlock(&area->lock);
 			return false;
 		}
-		mutex_unlock(&a->lock);
-	}
-
+		
+		mutex_unlock(&area->lock);
+	}
+	
 	/*
 	 * So far, the area does not conflict with other areas.
 	 * Check if it doesn't conflict with kernel address space.
-	 */	 
+	 *
+	 */
 	if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
-		return !overlaps(va, size, 
+		return !overlaps(va, size,
 		    KERNEL_ADDRESS_SPACE_START,
 		    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
 	}
-
+	
 	return true;
 }
@@ -1397,23 +1458,23 @@
 /** Return size of the address space area with given base.
  *
- * @param base		Arbitrary address insede the address space area.
- *
- * @return		Size of the address space area in bytes or zero if it
- *			does not exist.
+ * @param base Arbitrary address insede the address space area.
+ *
+ * @return Size of the address space area in bytes or zero if it
+ *         does not exist.
+ *
  */
 size_t as_area_get_size(uintptr_t base)
 {
-	ipl_t ipl;
-	as_area_t *src_area;
 	size_t size;
-
-	ipl = interrupts_disable();
-	src_area = find_area_and_lock(AS, base);
+	
+	ipl_t ipl = interrupts_disable();
+	as_area_t *src_area = find_area_and_lock(AS, base);
+	
 	if (src_area) {
 		size = src_area->pages * PAGE_SIZE;
 		mutex_unlock(&src_area->lock);
-	} else {
+	} else
 		size = 0;
-	}
+	
 	interrupts_restore(ipl);
 	return size;
@@ -1424,33 +1485,32 @@
  * The address space area must be already locked.
  *
- * @param a		Address space area.
- * @param page		First page to be marked.
- * @param count		Number of page to be marked.
- *
- * @return		Zero on failure and non-zero on success.
- */
-int used_space_insert(as_area_t *a, uintptr_t page, size_t count)
-{
-	btree_node_t *leaf, *node;
-	size_t pages;
-	unsigned int i;
-
+ * @param area  Address space area.
+ * @param page  First page to be marked.
+ * @param count Number of page to be marked.
+ *
+ * @return Zero on failure and non-zero on success.
+ *
+ */
+int used_space_insert(as_area_t *area, uintptr_t page, size_t count)
+{
 	ASSERT(page == ALIGN_DOWN(page, PAGE_SIZE));
 	ASSERT(count);
-
-	pages = (size_t) btree_search(&a->used_space, page, &leaf);
+	
+	btree_node_t *leaf;
+	size_t pages = (size_t) btree_search(&area->used_space, page, &leaf);
 	if (pages) {
 		/*
 		 * We hit the beginning of some used space.
+		 *
 		 */
 		return 0;
 	}
-
+	
 	if (!leaf->keys) {
-		btree_insert(&a->used_space, page, (void *) count, leaf);
+		btree_insert(&area->used_space, page, (void *) count, leaf);
 		return 1;
 	}
-
-	node = btree_leaf_node_left_neighbour(&a->used_space, leaf);
+	
+	btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space, leaf);
 	if (node) {
 		uintptr_t left_pg = node->key[node->keys - 1];
@@ -1463,6 +1523,7 @@
 		 * somewhere between the rightmost interval of
 		 * the left neigbour and the first interval of the leaf.
-		 */
-		 
+		 *
+		 */
+		
 		if (page >= right_pg) {
 			/* Do nothing. */
@@ -1474,5 +1535,5 @@
 		    right_cnt * PAGE_SIZE)) {
 			/* The interval intersects with the right interval. */
-			return 0;			
+			return 0;
 		} else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
 		    (page + count * PAGE_SIZE == right_pg)) {
@@ -1480,12 +1541,14 @@
 			 * The interval can be added by merging the two already
 			 * present intervals.
+			 *
 			 */
 			node->value[node->keys - 1] += count + right_cnt;
-			btree_remove(&a->used_space, right_pg, leaf);
-			return 1; 
+			btree_remove(&area->used_space, right_pg, leaf);
+			return 1;
 		} else if (page == left_pg + left_cnt * PAGE_SIZE) {
-			/* 
+			/*
 			 * The interval can be added by simply growing the left
 			 * interval.
+			 *
 			 */
 			node->value[node->keys - 1] += count;
@@ -1496,4 +1559,5 @@
 			 * the right interval down and increasing its size
 			 * accordingly.
+			 *
 			 */
 			leaf->value[0] += count;
@@ -1504,6 +1568,7 @@
 			 * The interval is between both neigbouring intervals,
 			 * but cannot be merged with any of them.
+			 *
 			 */
-			btree_insert(&a->used_space, page, (void *) count,
+			btree_insert(&area->used_space, page, (void *) count,
 			    leaf);
 			return 1;
@@ -1512,10 +1577,11 @@
 		uintptr_t right_pg = leaf->key[0];
 		size_t right_cnt = (size_t) leaf->value[0];
-	
+		
 		/*
 		 * Investigate the border case in which the left neighbour does
 		 * not exist but the interval fits from the left.
-		 */
-		 
+		 *
+		 */
+		
 		if (overlaps(page, count * PAGE_SIZE, right_pg,
 		    right_cnt * PAGE_SIZE)) {
@@ -1527,4 +1593,5 @@
 			 * right interval down and increasing its size
 			 * accordingly.
+			 *
 			 */
 			leaf->key[0] = page;
@@ -1535,12 +1602,13 @@
 			 * The interval doesn't adjoin with the right interval.
 			 * It must be added individually.
+			 *
 			 */
-			btree_insert(&a->used_space, page, (void *) count,
+			btree_insert(&area->used_space, page, (void *) count,
 			    leaf);
 			return 1;
 		}
 	}
-
-	node = btree_leaf_node_right_neighbour(&a->used_space, leaf);
+	
+	node = btree_leaf_node_right_neighbour(&area->used_space, leaf);
 	if (node) {
 		uintptr_t left_pg = leaf->key[leaf->keys - 1];
@@ -1553,6 +1621,7 @@
 		 * somewhere between the leftmost interval of
 		 * the right neigbour and the last interval of the leaf.
-		 */
-
+		 *
+		 */
+		
 		if (page < left_pg) {
 			/* Do nothing. */
@@ -1564,5 +1633,5 @@
 		    right_cnt * PAGE_SIZE)) {
 			/* The interval intersects with the right interval. */
-			return 0;			
+			return 0;
 		} else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
 		    (page + count * PAGE_SIZE == right_pg)) {
@@ -1570,13 +1639,15 @@
 			 * The interval can be added by merging the two already
 			 * present intervals.
-			 * */
+			 *
+			 */
 			leaf->value[leaf->keys - 1] += count + right_cnt;
-			btree_remove(&a->used_space, right_pg, node);
-			return 1; 
+			btree_remove(&area->used_space, right_pg, node);
+			return 1;
 		} else if (page == left_pg + left_cnt * PAGE_SIZE) {
 			/*
 			 * The interval can be added by simply growing the left
 			 * interval.
-			 * */
+			 *
+			 */
 			leaf->value[leaf->keys - 1] +=  count;
 			return 1;
@@ -1586,4 +1657,5 @@
 			 * the right interval down and increasing its size
 			 * accordingly.
+			 *
 			 */
 			node->value[0] += count;
@@ -1594,6 +1666,7 @@
 			 * The interval is between both neigbouring intervals,
 			 * but cannot be merged with any of them.
+			 *
 			 */
-			btree_insert(&a->used_space, page, (void *) count,
+			btree_insert(&area->used_space, page, (void *) count,
 			    leaf);
 			return 1;
@@ -1602,10 +1675,11 @@
 		uintptr_t left_pg = leaf->key[leaf->keys - 1];
 		size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
-	
+		
 		/*
 		 * Investigate the border case in which the right neighbour
 		 * does not exist but the interval fits from the right.
-		 */
-		 
+		 *
+		 */
+		
 		if (overlaps(page, count * PAGE_SIZE, left_pg,
 		    left_cnt * PAGE_SIZE)) {
@@ -1616,4 +1690,5 @@
 			 * The interval can be added by growing the left
 			 * interval.
+			 *
 			 */
 			leaf->value[leaf->keys - 1] += count;
@@ -1623,6 +1698,7 @@
 			 * The interval doesn't adjoin with the left interval.
 			 * It must be added individually.
+			 *
 			 */
-			btree_insert(&a->used_space, page, (void *) count,
+			btree_insert(&area->used_space, page, (void *) count,
 			    leaf);
 			return 1;
@@ -1634,5 +1710,7 @@
 	 * only between two other intervals of the leaf. The two border cases
 	 * were already resolved.
-	 */
+	 *
+	 */
+	btree_key_t i;
 	for (i = 1; i < leaf->keys; i++) {
 		if (page < leaf->key[i]) {
@@ -1641,9 +1719,10 @@
 			size_t left_cnt = (size_t) leaf->value[i - 1];
 			size_t right_cnt = (size_t) leaf->value[i];
-
+			
 			/*
 			 * The interval fits between left_pg and right_pg.
+			 *
 			 */
-
+			
 			if (overlaps(page, count * PAGE_SIZE, left_pg,
 			    left_cnt * PAGE_SIZE)) {
@@ -1651,4 +1730,5 @@
 				 * The interval intersects with the left
 				 * interval.
+				 *
 				 */
 				return 0;
@@ -1658,6 +1738,7 @@
 				 * The interval intersects with the right
 				 * interval.
+				 *
 				 */
-				return 0;			
+				return 0;
 			} else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
 			    (page + count * PAGE_SIZE == right_pg)) {
@@ -1665,12 +1746,14 @@
 				 * The interval can be added by merging the two
 				 * already present intervals.
+				 *
 				 */
 				leaf->value[i - 1] += count + right_cnt;
-				btree_remove(&a->used_space, right_pg, leaf);
-				return 1; 
+				btree_remove(&area->used_space, right_pg, leaf);
+				return 1;
 			} else if (page == left_pg + left_cnt * PAGE_SIZE) {
 				/*
 				 * The interval can be added by simply growing
 				 * the left interval.
+				 *
 				 */
 				leaf->value[i - 1] += count;
@@ -1678,8 +1761,9 @@
 			} else if (page + count * PAGE_SIZE == right_pg) {
 				/*
-			         * The interval can be addded by simply moving
+				 * The interval can be addded by simply moving
 				 * base of the right interval down and
 				 * increasing its size accordingly.
-			 	 */
+				 *
+				 */
 				leaf->value[i] += count;
 				leaf->key[i] = page;
@@ -1690,6 +1774,7 @@
 				 * intervals, but cannot be merged with any of
 				 * them.
+				 *
 				 */
-				btree_insert(&a->used_space, page,
+				btree_insert(&area->used_space, page,
 				    (void *) count, leaf);
 				return 1;
@@ -1697,5 +1782,5 @@
 		}
 	}
-
+	
 	panic("Inconsistency detected while adding %" PRIs " pages of used "
 	    "space at %p.", count, page);
@@ -1706,28 +1791,27 @@
  * The address space area must be already locked.
  *
- * @param a		Address space area.
- * @param page		First page to be marked.
- * @param count		Number of page to be marked.
- *
- * @return		Zero on failure and non-zero on success.
- */
-int used_space_remove(as_area_t *a, uintptr_t page, size_t count)
-{
-	btree_node_t *leaf, *node;
-	size_t pages;
-	unsigned int i;
-
+ * @param area  Address space area.
+ * @param page  First page to be marked.
+ * @param count Number of page to be marked.
+ *
+ * @return Zero on failure and non-zero on success.
+ *
+ */
+int used_space_remove(as_area_t *area, uintptr_t page, size_t count)
+{
 	ASSERT(page == ALIGN_DOWN(page, PAGE_SIZE));
 	ASSERT(count);
-
-	pages = (size_t) btree_search(&a->used_space, page, &leaf);
+	
+	btree_node_t *leaf;
+	size_t pages = (size_t) btree_search(&area->used_space, page, &leaf);
 	if (pages) {
 		/*
 		 * We are lucky, page is the beginning of some interval.
+		 *
 		 */
 		if (count > pages) {
 			return 0;
 		} else if (count == pages) {
-			btree_remove(&a->used_space, page, leaf);
+			btree_remove(&area->used_space, page, leaf);
 			return 1;
 		} else {
@@ -1735,5 +1819,7 @@
 			 * Find the respective interval.
 			 * Decrease its size and relocate its start address.
+			 *
 			 */
+			btree_key_t i;
 			for (i = 0; i < leaf->keys; i++) {
 				if (leaf->key[i] == page) {
@@ -1746,10 +1832,10 @@
 		}
 	}
-
-	node = btree_leaf_node_left_neighbour(&a->used_space, leaf);
-	if (node && page < leaf->key[0]) {
+	
+	btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space, leaf);
+	if ((node) && (page < leaf->key[0])) {
 		uintptr_t left_pg = node->key[node->keys - 1];
 		size_t left_cnt = (size_t) node->value[node->keys - 1];
-
+		
 		if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,
 		    count * PAGE_SIZE)) {
@@ -1761,4 +1847,5 @@
 				 * removed by updating the size of the bigger
 				 * interval.
+				 *
 				 */
 				node->value[node->keys - 1] -= count;
@@ -1766,6 +1853,4 @@
 			} else if (page + count * PAGE_SIZE <
 			    left_pg + left_cnt*PAGE_SIZE) {
-				size_t new_cnt;
-				
 				/*
 				 * The interval is contained in the rightmost
@@ -1774,9 +1859,10 @@
 				 * the original interval and also inserting a
 				 * new interval.
+				 *
 				 */
-				new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -
+				size_t new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -
 				    (page + count*PAGE_SIZE)) >> PAGE_WIDTH;
 				node->value[node->keys - 1] -= count + new_cnt;
-				btree_insert(&a->used_space, page +
+				btree_insert(&area->used_space, page +
 				    count * PAGE_SIZE, (void *) new_cnt, leaf);
 				return 1;
@@ -1784,15 +1870,14 @@
 		}
 		return 0;
-	} else if (page < leaf->key[0]) {
+	} else if (page < leaf->key[0])
 		return 0;
-	}
 	
 	if (page > leaf->key[leaf->keys - 1]) {
 		uintptr_t left_pg = leaf->key[leaf->keys - 1];
 		size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
-
+		
 		if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,
 		    count * PAGE_SIZE)) {
-			if (page + count * PAGE_SIZE == 
+			if (page + count * PAGE_SIZE ==
 			    left_pg + left_cnt * PAGE_SIZE) {
 				/*
@@ -1800,4 +1885,5 @@
 				 * interval of the leaf and can be removed by
 				 * updating the size of the bigger interval.
+				 *
 				 */
 				leaf->value[leaf->keys - 1] -= count;
@@ -1805,6 +1891,4 @@
 			} else if (page + count * PAGE_SIZE < left_pg +
 			    left_cnt * PAGE_SIZE) {
-				size_t new_cnt;
-				
 				/*
 				 * The interval is contained in the rightmost
@@ -1813,9 +1897,10 @@
 				 * original interval and also inserting a new
 				 * interval.
+				 *
 				 */
-				new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -
+				size_t new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -
 				    (page + count * PAGE_SIZE)) >> PAGE_WIDTH;
 				leaf->value[leaf->keys - 1] -= count + new_cnt;
-				btree_insert(&a->used_space, page +
+				btree_insert(&area->used_space, page +
 				    count * PAGE_SIZE, (void *) new_cnt, leaf);
 				return 1;
@@ -1823,5 +1908,5 @@
 		}
 		return 0;
-	}	
+	}
 	
 	/*
@@ -1829,9 +1914,10 @@
 	 * Now the interval can be only between intervals of the leaf. 
 	 */
+	btree_key_t i;
 	for (i = 1; i < leaf->keys - 1; i++) {
 		if (page < leaf->key[i]) {
 			uintptr_t left_pg = leaf->key[i - 1];
 			size_t left_cnt = (size_t) leaf->value[i - 1];
-
+			
 			/*
 			 * Now the interval is between intervals corresponding
@@ -1847,4 +1933,5 @@
 					 * be removed by updating the size of
 					 * the bigger interval.
+					 *
 					 */
 					leaf->value[i - 1] -= count;
@@ -1852,6 +1939,4 @@
 				} else if (page + count * PAGE_SIZE <
 				    left_pg + left_cnt * PAGE_SIZE) {
-					size_t new_cnt;
-				
 					/*
 					 * The interval is contained in the
@@ -1861,10 +1946,10 @@
 					 * also inserting a new interval.
 					 */
-					new_cnt = ((left_pg +
+					size_t new_cnt = ((left_pg +
 					    left_cnt * PAGE_SIZE) -
 					    (page + count * PAGE_SIZE)) >>
 					    PAGE_WIDTH;
 					leaf->value[i - 1] -= count + new_cnt;
-					btree_insert(&a->used_space, page +
+					btree_insert(&area->used_space, page +
 					    count * PAGE_SIZE, (void *) new_cnt,
 					    leaf);
@@ -1875,5 +1960,5 @@
 		}
 	}
-
+	
 error:
 	panic("Inconsistency detected while removing %" PRIs " pages of used "
@@ -1885,12 +1970,14 @@
  * If the reference count drops to 0, the sh_info is deallocated.
  *
- * @param sh_info	Pointer to address space area share info.
+ * @param sh_info Pointer to address space area share info.
+ *
  */
 void sh_info_remove_reference(share_info_t *sh_info)
 {
 	bool dealloc = false;
-
+	
 	mutex_lock(&sh_info->lock);
 	ASSERT(sh_info->refcount);
+	
 	if (--sh_info->refcount == 0) {
 		dealloc = true;
@@ -1903,9 +1990,9 @@
 		for (cur = sh_info->pagemap.leaf_head.next;
 		    cur != &sh_info->pagemap.leaf_head; cur = cur->next) {
-			btree_node_t *node;
-			unsigned int i;
+			btree_node_t *node
+			    = list_get_instance(cur, btree_node_t, leaf_link);
+			btree_key_t i;
 			
-			node = list_get_instance(cur, btree_node_t, leaf_link);
-			for (i = 0; i < node->keys; i++) 
+			for (i = 0; i < node->keys; i++)
 				frame_free((uintptr_t) node->value[i]);
 		}
@@ -1925,5 +2012,5 @@
 
 /** Wrapper for as_area_create(). */
-unative_t sys_as_area_create(uintptr_t address, size_t size, int flags)
+unative_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
 {
 	if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,
@@ -1935,5 +2022,5 @@
 
 /** Wrapper for as_area_resize(). */
-unative_t sys_as_area_resize(uintptr_t address, size_t size, int flags)
+unative_t sys_as_area_resize(uintptr_t address, size_t size, unsigned int flags)
 {
 	return (unative_t) as_area_resize(AS, address, size, 0);
@@ -1941,5 +2028,5 @@
 
 /** Wrapper for as_area_change_flags(). */
-unative_t sys_as_area_change_flags(uintptr_t address, int flags)
+unative_t sys_as_area_change_flags(uintptr_t address, unsigned int flags)
 {
 	return (unative_t) as_area_change_flags(AS, flags, address);
@@ -1954,77 +2041,69 @@
 /** Get list of adress space areas.
  *
- * @param as		Address space.
- * @param obuf		Place to save pointer to returned buffer.
- * @param osize		Place to save size of returned buffer.
+ * @param as    Address space.
+ * @param obuf  Place to save pointer to returned buffer.
+ * @param osize Place to save size of returned buffer.
+ *
  */
 void as_get_area_info(as_t *as, as_area_info_t **obuf, size_t *osize)
 {
-	ipl_t ipl;
-	size_t area_cnt, area_idx, i;
+	ipl_t ipl = interrupts_disable();
+	mutex_lock(&as->lock);
+	
+	/* First pass, count number of areas. */
+	
+	size_t area_cnt = 0;
 	link_t *cur;
-
-	as_area_info_t *info;
-	size_t isize;
-
-	ipl = interrupts_disable();
-	mutex_lock(&as->lock);
-
-	/* First pass, count number of areas. */
-
-	area_cnt = 0;
-
+	
 	for (cur = as->as_area_btree.leaf_head.next;
 	    cur != &as->as_area_btree.leaf_head; cur = cur->next) {
-		btree_node_t *node;
-
-		node = list_get_instance(cur, btree_node_t, leaf_link);
+		btree_node_t *node =
+		    list_get_instance(cur, btree_node_t, leaf_link);
 		area_cnt += node->keys;
 	}
-
-        isize = area_cnt * sizeof(as_area_info_t);
-	info = malloc(isize, 0);
-
+	
+	size_t isize = area_cnt * sizeof(as_area_info_t);
+	as_area_info_t *info = malloc(isize, 0);
+	
 	/* Second pass, record data. */
-
-	area_idx = 0;
-
+	
+	size_t area_idx = 0;
+	
 	for (cur = as->as_area_btree.leaf_head.next;
 	    cur != &as->as_area_btree.leaf_head; cur = cur->next) {
-		btree_node_t *node;
-
-		node = list_get_instance(cur, btree_node_t, leaf_link);
-
+		btree_node_t *node =
+		    list_get_instance(cur, btree_node_t, leaf_link);
+		btree_key_t i;
+		
 		for (i = 0; i < node->keys; i++) {
 			as_area_t *area = node->value[i];
-
+			
 			ASSERT(area_idx < area_cnt);
 			mutex_lock(&area->lock);
-
+			
 			info[area_idx].start_addr = area->base;
 			info[area_idx].size = FRAMES2SIZE(area->pages);
 			info[area_idx].flags = area->flags;
 			++area_idx;
-
+			
 			mutex_unlock(&area->lock);
 		}
 	}
-
+	
 	mutex_unlock(&as->lock);
 	interrupts_restore(ipl);
-
+	
 	*obuf = info;
 	*osize = isize;
 }
 
-
 /** Print out information about address space.
  *
- * @param as		Address space.
+ * @param as Address space.
+ *
  */
 void as_print(as_t *as)
 {
-	ipl_t ipl;
-	
-	ipl = interrupts_disable();
+	ipl_t ipl = interrupts_disable();
 	mutex_lock(&as->lock);
 	
@@ -2033,12 +2112,11 @@
 	for (cur = as->as_area_btree.leaf_head.next;
 	    cur != &as->as_area_btree.leaf_head; cur = cur->next) {
-		btree_node_t *node;
-		
-		node = list_get_instance(cur, btree_node_t, leaf_link);
-		
-		unsigned int i;
+		btree_node_t *node
+		    = list_get_instance(cur, btree_node_t, leaf_link);
+		btree_key_t i;
+		
 		for (i = 0; i < node->keys; i++) {
 			as_area_t *area = node->value[i];
-		
+			
 			mutex_lock(&area->lock);
 			printf("as_area: %p, base=%p, pages=%" PRIs
