Changeset 46c20c8 in mainline for kernel/generic/src/mm

Timestamp:

2010-11-26T20:08:10Z (15 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

45df59a

Parents:

fb150d78 (diff), ffdd2b9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

Location:

kernel/generic/src/mm

Files:

• as.c (modified) (92 diffs)
• backend_anon.c (modified) (4 diffs)
• backend_elf.c (modified) (6 diffs)
• backend_phys.c (modified) (3 diffs)
• buddy.c (modified) (1 diff)
• frame.c (modified) (65 diffs)
• page.c (modified) (7 diffs)
• slab.c (modified) (32 diffs)
• tlb.c (modified) (8 diffs)

kernel/generic/src/mm/as.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2001-2006 Jakub Jermar
+ * Copyright (c) 2010 Jakub Jermar
  * All rights reserved.
  *
@@ -33 +33 @@
 /**
  * @file
- * @brief       Address space related functions.
+ * @brief Address space related functions.
  *
  * This file contains address space manipulation functions.
@@ -75 +75 @@
 #include <config.h>
 #include <align.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <syscall/copy.h>
 #include <arch/interrupt.h>
@@ -86 +86 @@
  * 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 +92 @@
 /**
  * Slab for as_t objects.
+ *
  */
 static slab_cache_t *as_slab;
@@ -100 +102 @@
  * - as->asid for each as of the as_t type
  * - asids_allocated counter
+ *
  */
 SPINLOCK_INITIALIZE(asidlock);
@@ -106 +109 @@
  * 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 +116 @@
 as_t *AS_KERNEL = NULL;
 
-static int area_flags_to_page_flags(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)
+NO_TRACE 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)
+NO_TRACE static size_t as_destructor(void *obj)
 {
         as_t *as = (as_t *) obj;
-
         return as_destructor_arch(as);
 }
@@ -141 +138 @@
 {
         as_arch_init();
-
+        
         as_slab = slab_cache_create("as_slab", sizeof(as_t), 0,
             as_constructor, as_destructor, SLAB_CACHE_MAGDEFERRED);
@@ -152 +149 @@
          * reference count never drops to zero.
          */
-        atomic_set(&AS_KERNEL->refcount, 1);
+        as_hold(AS_KERNEL);
 }
 
 /** 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 +172 @@
         atomic_set(&as->refcount, 0);
         as->cpu_refcount = 0;
+        
 #ifdef AS_PAGE_TABLE
         as->genarch.page_table = page_table_create(flags);
@@ -192 +189 @@
  * 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);
 
+        ASSERT(as != AS);
         ASSERT(atomic_get(&as->refcount) == 0);
         
         /*
-         * Since there is no reference to this area,
-         * it is safe not to lock its mutex.
+         * Since there is no reference to this address space, it is safe not to
+         * lock its mutex.
          */
 
@@ -213 +210 @@
          * 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();
@@ -223 +222 @@
                 goto retry;
         }
-        preemption_enable();    /* Interrupts disabled, enable preemption */
-        if (as->asid != ASID_INVALID && as != AS_KERNEL) {
-                if (as != AS && as->cpu_refcount == 0)
+        
+        /* 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);
-
+        interrupts_restore(ipl);
+
+        
         /*
          * 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);
@@ -254 +262 @@
         page_table_destroy(NULL);
 #endif
-
-        interrupts_restore(ipl);
-
+        
         slab_free(as_slab, as);
 }
 
+/** Hold a reference to an address space.
+ *
+ * Holding a reference to an address space prevents destruction of that address
+ * space.
+ *
+ * @param as Address space to be held.
+ *
+ */
+NO_TRACE void as_hold(as_t *as)
+{
+        atomic_inc(&as->refcount);
+}
+
+/** Release a reference to an address space.
+ *
+ * The last one to release a reference to an address space destroys the address
+ * space.
+ *
+ * @param asAddress space to be released.
+ *
+ */
+NO_TRACE void as_release(as_t *as)
+{
+        if (atomic_predec(&as->refcount) == 0)
+                as_destroy(as);
+}
+
+/** Check area conflicts with other areas.
+ *
+ * @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.
+ *
+ */
+NO_TRACE static bool check_area_conflicts(as_t *as, uintptr_t va, size_t size,
+    as_area_t *avoid_area)
+{
+        ASSERT(mutex_locked(&as->lock));
+        
+        /*
+         * We don't want any area to have conflicts with NULL page.
+         *
+         */
+        if (overlaps(va, size, (uintptr_t) NULL, PAGE_SIZE))
+                return false;
+        
+        /*
+         * The leaf node is found in O(log n), where n is proportional to
+         * the number of address space areas belonging to as.
+         * The check for conflicts is then attempted on the rightmost
+         * record in the left neighbour, the leftmost record in the right
+         * neighbour and all records in the leaf node itself.
+         *
+         */
+        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. */
+        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(&area->lock);
+        }
+        
+        node = btree_leaf_node_right_neighbour(&as->as_area_btree, leaf);
+        if (node) {
+                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(&area->lock);
+        }
+        
+        /* Second, check the leaf node. */
+        btree_key_t i;
+        for (i = 0; i < leaf->keys; i++) {
+                area = (as_area_t *) leaf->value[i];
+                
+                if (area == avoid_area)
+                        continue;
+                
+                mutex_lock(&area->lock);
+                
+                if (overlaps(va, size, area->base, area->pages * PAGE_SIZE)) {
+                        mutex_unlock(&area->lock);
+                        return false;
+                }
+                
+                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,
+                    KERNEL_ADDRESS_SPACE_START,
+                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
+        }
+        
+        return true;
+}
+
 /** Create address space area of common attributes.
  *
  * 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();
         mutex_lock(&as->lock);
         
         if (!check_area_conflicts(as, base, size, NULL)) {
                 mutex_unlock(&as->lock);
-                interrupts_restore(ipl);
                 return NULL;
         }
         
-        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 lock it.
+ *
+ * @param as Address space.
+ * @param va Virtual address.
+ *
+ * @return Locked address space area containing va on success or
+ *         NULL on failure.
+ *
+ */
+NO_TRACE static as_area_t *find_area_and_lock(as_t *as, uintptr_t va)
+{
+        ASSERT(mutex_locked(&as->lock));
+        
+        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(&area->lock);
+                return area;
+        }
+        
+        /*
+         * Search the leaf node and the righmost record of its left neighbour
+         * 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++) {
+                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.
+         *
+         */
+        btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf);
+        if (lnode) {
+                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;
 }
 
 /** 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)
+{
         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);
-                interrupts_restore(ipl);
                 return ENOENT;
         }
-
+        
         if (area->backend == &phys_backend) {
                 /*
                  * Remapping of address space areas associated
                  * with memory mapped devices is not supported.
+                 *
                  */
                 mutex_unlock(&area->lock);
                 mutex_unlock(&as->lock);
-                interrupts_restore(ipl);
                 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);
                 mutex_unlock(&as->lock);
-                interrupts_restore(ipl);
                 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);
                 mutex_unlock(&as->lock);
-                interrupts_restore(ipl);
                 return EPERM;
         }
         
         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);
-
+                 *
+                 */
+                ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid,
+                    area->base + pages * PAGE_SIZE, area->pages - pages);
+                
                 /*
                  * Remove frames belonging to used space starting from
@@ -409 +599 @@
                  * 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 {
                                         /*
@@ -452 +646 @@
                                          * 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;
-                        
-                                        page_table_lock(as, false);
-                                        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);
-                                        page_table_unlock(as, false);
                                 }
                         }
                 }
-
+                
                 /*
                  * 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();
-                
+                tlb_shootdown_finalize(ipl);
+                
+                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);                
-                        interrupts_restore(ipl);
+                        mutex_unlock(&as->lock);
                         return EADDRNOTAVAIL;
                 }
-        } 
-
+        }
+        
         area->pages = pages;
         
         mutex_unlock(&area->lock);
         mutex_unlock(&as->lock);
-        interrupts_restore(ipl);
-
+        
         return 0;
 }
 
+/** Remove reference to address space area share info.
+ *
+ * If the reference count drops to 0, the sh_info is deallocated.
+ *
+ * @param sh_info Pointer to address space area share info.
+ *
+ */
+NO_TRACE static 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;
+                link_t *cur;
+                
+                /*
+                 * Now walk carefully the pagemap B+tree and free/remove
+                 * reference from all frames found there.
+                 */
+                for (cur = sh_info->pagemap.leaf_head.next;
+                    cur != &sh_info->pagemap.leaf_head; cur = cur->next) {
+                        btree_node_t *node
+                            = list_get_instance(cur, btree_node_t, leaf_link);
+                        btree_key_t i;
+                        
+                        for (i = 0; i < node->keys; i++)
+                                frame_free((uintptr_t) node->value[i]);
+                }
+                
+        }
+        mutex_unlock(&sh_info->lock);
+        
+        if (dealloc) {
+                btree_destroy(&sh_info->pagemap);
+                free(sh_info);
+        }
+}
+
 /** 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();
         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);
-                interrupts_restore(ipl);
                 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);
-
+        ipl_t ipl = 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++) {
-                                page_table_lock(as, false);
-                                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_table_unlock(as, false);
+                                
+                                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();
+        tlb_shootdown_finalize(ipl);
+        
+        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);
@@ -604 +846 @@
         
         mutex_unlock(&as->lock);
-        interrupts_restore(ipl);
         return 0;
 }
@@ -615 +856 @@
  * 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)
+{
         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);
-                interrupts_restore(ipl);
                 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);
                 mutex_unlock(&src_as->lock);
-                interrupts_restore(ipl);
                 return ENOTSUP;
         }
         
-        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);
-                interrupts_restore(ipl);
                 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);
@@ -693 +927 @@
                 btree_create(&sh_info->pagemap);
                 src_area->sh_info = sh_info;
+                
                 /*
                  * Call the backend to setup sharing.
+                 *
                  */
                 src_area->backend->share(src_area);
@@ -702 +938 @@
                 mutex_unlock(&sh_info->lock);
         }
-
+        
         mutex_unlock(&src_area->lock);
         mutex_unlock(&src_as->lock);
-
+        
         /*
          * Create copy of the source address space area.
@@ -713 +949 @@
          * 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) {
                 /*
@@ -722 +959 @@
                 sh_info_remove_reference(sh_info);
                 
-                interrupts_restore(ipl);
                 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);    
-
-        interrupts_restore(ipl);
+        mutex_unlock(&dst_as->lock);
         
         return 0;
@@ -745 +980 @@
 /** Check access mode for address space area.
  *
- * 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.
- */
-bool as_area_check_access(as_area_t *area, pf_access_t access)
+ * @param area   Address space area.
+ * @param access Access mode.
+ *
+ * @return False if access violates area's permissions, true
+ *         otherwise.
+ *
+ */
+NO_TRACE bool as_area_check_access(as_area_t *area, pf_access_t access)
 {
         int flagmap[] = {
@@ -761 +995 @@
         };
 
+        ASSERT(mutex_locked(&area->lock));
+        
         if (!(area->flags & flagmap[access]))
                 return false;
         
         return true;
+}
+
+/** 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().
+ *
+ */
+NO_TRACE static unsigned int area_flags_to_page_flags(unsigned int aflags)
+{
+        unsigned int flags = PAGE_USER | PAGE_PRESENT;
+        
+        if (aflags & AS_AREA_READ)
+                flags |= PAGE_READ;
+                
+        if (aflags & AS_AREA_WRITE)
+                flags |= PAGE_WRITE;
+        
+        if (aflags & AS_AREA_EXEC)
+                flags |= PAGE_EXEC;
+        
+        if (aflags & AS_AREA_CACHEABLE)
+                flags |= PAGE_CACHEABLE;
+        
+        return flags;
 }
 
@@ -781 +1043 @@
  *
  */
-int as_area_change_flags(as_t *as, int flags, uintptr_t address)
-{
-        as_area_t *area;
-        uintptr_t base;
-        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);
+        
         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);
-                interrupts_restore(ipl);
                 return ENOENT;
         }
-
+        
         if ((area->sh_info) || (area->backend != &anon_backend)) {
                 /* Copying shared areas not supported yet */
@@ -810 +1061 @@
                 mutex_unlock(&area->lock);
                 mutex_unlock(&as->lock);
-                interrupts_restore(ipl);
                 return ENOTSUP;
         }
-
-        base = area->base;
-
+        
         /*
          * 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);
-
+         *
+         */
+        ipl_t ipl = 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++) {
+                        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, 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(ipl);
+        
+        page_table_unlock(as, false);
+        
+        /*
+         * Set the new flags.
+         */
+        area->flags = flags;
+        
+        /*
+         * Map pages back in with new flags. This step is kept separate
+         * so that the memory area could not be accesed with both the old and
+         * the new flags at once.
+         */
+        frame_idx = 0;
+        
+        for (cur = area->used_space.leaf_head.next;
+            cur != &area->used_space.leaf_head; cur = cur->next) {
+                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 ptr = node->key[i];
+                        size_t size;
+                        
+                        for (size = 0; size < (size_t) node->value[i]; size++) {
                                 page_table_lock(as, false);
-                                pte = page_mapping_find(as, b + j * PAGE_SIZE);
-                                ASSERT(pte && PTE_VALID(pte) &&
-                                    PTE_PRESENT(pte));
-                                old_frame[frame_idx++] = PTE_GET_FRAME(pte);
-
-                                /* Remove old mapping */
-                                page_mapping_remove(as, b + j * PAGE_SIZE);
+                                
+                                /* Insert the new mapping */
+                                page_mapping_insert(as, ptr + size * PAGE_SIZE,
+                                    old_frame[frame_idx++], page_flags);
+                                
                                 page_table_unlock(as, false);
                         }
                 }
         }
-
-        /*
-         * 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();
-
-        /*
-         * Set the new flags.
-         */
-        area->flags = flags;
-
-        /*
-         * Map pages back in with new flags. This step is kept separate
-         * so that the memory area could not be accesed with both the old and
-         * the new flags at once.
-         */
-        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);
-                for (i = 0; i < node->keys; i++) {
-                        uintptr_t b = node->key[i];
-                        size_t j;
-                        
-                        for (j = 0; j < (size_t) node->value[i]; j++) {
-                                page_table_lock(as, false);
-
-                                /* Insert the new mapping */
-                                page_mapping_insert(as, b + j * 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.
@@ -936 +1192 @@
  * 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;
-                
-        ASSERT(AS);
-
+        
+        if (!AS)
+                return AS_PF_FAULT;
+        
         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) {
                 /*
@@ -973 +1230 @@
                 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);
         
@@ -991 +1249 @@
          * 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)) {
@@ -1007 +1267 @@
         /*
          * Resort to the backend page fault handler.
+         *
          */
         if (area->backend->page_fault(area, page, access) != AS_PF_OK) {
@@ -1019 +1280 @@
         mutex_unlock(&AS->lock);
         return AS_PF_OK;
-
+        
 page_fault:
         if (THREAD->in_copy_from_uspace) {
@@ -1032 +1293 @@
                 return AS_PF_FAULT;
         }
-
+        
         return AS_PF_DEFER;
 }
@@ -1044 +1305 @@
  * 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)
@@ -1051 +1313 @@
         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();
@@ -1065 +1329 @@
         }
         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
@@ -1077 +1342 @@
                          * 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)) {
@@ -1099 +1368 @@
                         new_as->asid = asid_get();
         }
+        
 #ifdef AS_PAGE_TABLE
         SET_PTL0_ADDRESS(new_as->genarch.page_table);
@@ -1106 +1376 @@
          * Perform architecture-specific steps.
          * (e.g. write ASID to hardware register etc.)
+         *
          */
         as_install_arch(new_as);
-
+        
         spinlock_unlock(&asidlock);
         
@@ -1114 +1385 @@
 }
 
-/** 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;
-        
-        if (aflags & AS_AREA_READ)
-                flags |= PAGE_READ;
-                
-        if (aflags & AS_AREA_WRITE)
-                flags |= PAGE_WRITE;
-        
-        if (aflags & AS_AREA_EXEC)
-                flags |= PAGE_EXEC;
-        
-        if (aflags & AS_AREA_CACHEABLE)
-                flags |= PAGE_CACHEABLE;
-                
-        return flags;
-}
-
 /** Compute flags for virtual address translation subsytem.
  *
- * The address space area must be locked.
- * 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().
+ *
+ */
+NO_TRACE unsigned int as_area_get_flags(as_area_t *area)
+{
+        ASSERT(mutex_locked(&area->lock));
+
+        return area_flags_to_page_flags(area->flags);
 }
 
@@ -1160 +1404 @@
  * 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.
+ *
+ */
+NO_TRACE pte_t *page_table_create(unsigned int flags)
 {
         ASSERT(as_operations);
@@ -1177 +1422 @@
  * Destroy page table in architecture specific way.
  *
- * @param page_table    Physical address of PTL0.
- */
-void page_table_destroy(pte_t *page_table)
+ * @param page_table Physical address of PTL0.
+ *
+ */
+NO_TRACE void page_table_destroy(pte_t *page_table)
 {
         ASSERT(as_operations);
@@ -1191 +1437 @@
  * 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.
- */
-void page_table_lock(as_t *as, bool lock)
+ * @param as   Address space.
+ * @param lock If false, do not attempt to lock as->lock.
+ *
+ */
+NO_TRACE void page_table_lock(as_t *as, bool lock)
 {
         ASSERT(as_operations);
@@ -1209 +1456 @@
 /** Unlock page table.
  *
- * @param as            Address space.
- * @param unlock        If false, do not attempt to unlock as->lock.
- */
-void page_table_unlock(as_t *as, bool unlock)
+ * @param as     Address space.
+ * @param unlock If false, do not attempt to unlock as->lock.
+ *
+ */
+NO_TRACE void page_table_unlock(as_t *as, bool unlock)
 {
         ASSERT(as_operations);
@@ -1220 +1468 @@
 }
 
-
-/** Find address space area and lock it.
- *
- * 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.
- */
-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) {
-                /* va is the base address of an address space area */
-                mutex_lock(&a->lock);
-                return a;
-        }
-        
-        /*
-         * Search the leaf node and the righmost record of its left neighbour
-         * to find out whether this is a miss or va belongs to an address
-         * space area found there.
-         */
-        
-        /* First, search the leaf node itself. */
-        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);
-        }
-
-        /*
-         * 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);
-        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);
-        }
-
-        return NULL;
-}
-
-/** Check area conflicts with other areas.
- *
- * 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;
-        
-        /*
-         * We don't want any area to have conflicts with NULL page.
-         */
-        if (overlaps(va, size, NULL, PAGE_SIZE))
-                return false;
-        
-        /*
-         * The leaf node is found in O(log n), where n is proportional to
-         * the number of address space areas belonging to as.
-         * The check for conflicts is then attempted on the rightmost
-         * 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)
-                        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);
-                        return false;
-                }
-                mutex_unlock(&a->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);
-                        return false;
-                }
-                mutex_unlock(&a->lock);
-        }
-        
-        /* Second, check the leaf node. */
-        for (i = 0; i < leaf->keys; i++) {
-                a = (as_area_t *) leaf->value[i];
-        
-                if (a == avoid_area)
-                        continue;
-        
-                mutex_lock(&a->lock);
-                if (overlaps(va, size, a->base, a->pages * PAGE_SIZE)) {
-                        mutex_unlock(&a->lock);
-                        return false;
-                }
-                mutex_unlock(&a->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, 
-                    KERNEL_ADDRESS_SPACE_START,
-                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
-        }
-
-        return true;
+/** Test whether page tables are locked.
+ *
+ * @param as Address space where the page tables belong.
+ *
+ * @return True if the page tables belonging to the address soace
+ *         are locked, otherwise false.
+ */
+NO_TRACE bool page_table_locked(as_t *as)
+{
+        ASSERT(as_operations);
+        ASSERT(as_operations->page_table_locked);
+
+        return as_operations->page_table_locked(as);
 }
 
 /** 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 inside 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);
+        
+        page_table_lock(AS, true);
+        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);
+        
+        page_table_unlock(AS, true);
         return size;
 }
@@ -1392 +1512 @@
  * 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(mutex_locked(&area->lock));
         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];
@@ -1431 +1551 @@
                  * somewhere between the rightmost interval of
                  * the left neigbour and the first interval of the leaf.
-                 */
-                 
+                 *
+                 */
+                
                 if (page >= right_pg) {
                         /* Do nothing. */
@@ -1442 +1563 @@
                     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)) {
@@ -1448 +1569 @@
                          * 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;
@@ -1464 +1587 @@
                          * the right interval down and increasing its size
                          * accordingly.
+                         *
                          */
                         leaf->value[0] += count;
@@ -1472 +1596 @@
                          * 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;
@@ -1480 +1605 @@
                 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)) {
@@ -1495 +1621 @@
                          * right interval down and increasing its size
                          * accordingly.
+                         *
                          */
                         leaf->key[0] = page;
@@ -1503 +1630 @@
                          * 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];
@@ -1521 +1649 @@
                  * somewhere between the leftmost interval of
                  * the right neigbour and the last interval of the leaf.
-                 */
-
+                 *
+                 */
+                
                 if (page < left_pg) {
                         /* Do nothing. */
@@ -1532 +1661 @@
                     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)) {
@@ -1538 +1667 @@
                          * 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;
@@ -1554 +1685 @@
                          * the right interval down and increasing its size
                          * accordingly.
+                         *
                          */
                         node->value[0] += count;
@@ -1562 +1694 @@
                          * 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;
@@ -1570 +1703 @@
                 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)) {
@@ -1584 +1718 @@
                          * The interval can be added by growing the left
                          * interval.
+                         *
                          */
                         leaf->value[leaf->keys - 1] += count;
@@ -1591 +1726 @@
                          * 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;
@@ -1602 +1738 @@
          * 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]) {
@@ -1609 +1747 @@
                         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)) {
@@ -1619 +1758 @@
                                  * The interval intersects with the left
                                  * interval.
+                                 *
                                  */
                                 return 0;
@@ -1626 +1766 @@
                                  * 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)) {
@@ -1633 +1774 @@
                                  * 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;
@@ -1646 +1789 @@
                         } 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;
@@ -1658 +1802 @@
                                  * 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;
@@ -1665 +1810 @@
                 }
         }
-
-        panic("Inconsistency detected while adding %" PRIs " pages of used "
-            "space at %p.", count, page);
+        
+        panic("Inconsistency detected while adding %zu pages of used "
+            "space at %p.", count, (void *) page);
 }
 
@@ -1674 +1819 @@
  * 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(mutex_locked(&area->lock));
         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 {
@@ -1703 +1848 @@
                          * 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) {
@@ -1714 +1861 @@
                 }
         }
-
-        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)) {
@@ -1729 +1876 @@
                                  * removed by updating the size of the bigger
                                  * interval.
+                                 *
                                  */
                                 node->value[node->keys - 1] -= count;
@@ -1734 +1882 @@
                         } else if (page + count * PAGE_SIZE <
                             left_pg + left_cnt*PAGE_SIZE) {
-                                size_t new_cnt;
-                                
                                 /*
                                  * The interval is contained in the rightmost
@@ -1742 +1888 @@
                                  * 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;
@@ -1752 +1899 @@
                 }
                 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) {
                                 /*
@@ -1768 +1914 @@
                                  * interval of the leaf and can be removed by
                                  * updating the size of the bigger interval.
+                                 *
                                  */
                                 leaf->value[leaf->keys - 1] -= count;
@@ -1773 +1920 @@
                         } else if (page + count * PAGE_SIZE < left_pg +
                             left_cnt * PAGE_SIZE) {
-                                size_t new_cnt;
-                                
                                 /*
                                  * The interval is contained in the rightmost
@@ -1781 +1926 @@
                                  * 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;
@@ -1791 +1937 @@
                 }
                 return 0;
-        }       
+        }
         
         /*
@@ -1797 +1943 @@
          * 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
@@ -1815 +1962 @@
                                          * be removed by updating the size of
                                          * the bigger interval.
+                                         *
                                          */
                                         leaf->value[i - 1] -= count;
@@ -1820 +1968 @@
                                 } else if (page + count * PAGE_SIZE <
                                     left_pg + left_cnt * PAGE_SIZE) {
-                                        size_t new_cnt;
-                                
                                         /*
                                          * The interval is contained in the
@@ -1829 +1975 @@
                                          * 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);
@@ -1843 +1989 @@
                 }
         }
-
+        
 error:
-        panic("Inconsistency detected while removing %" PRIs " pages of used "
-            "space from %p.", count, page);
-}
-
-/** Remove reference to address space area share info.
- *
- * If the reference count drops to 0, the sh_info is deallocated.
- *
- * @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;
-                link_t *cur;
-                
-                /*
-                 * Now walk carefully the pagemap B+tree and free/remove
-                 * reference from all frames found there.
-                 */
-                for (cur = sh_info->pagemap.leaf_head.next;
-                    cur != &sh_info->pagemap.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++) 
-                                frame_free((uintptr_t) node->value[i]);
-                }
-                
-        }
-        mutex_unlock(&sh_info->lock);
-        
-        if (dealloc) {
-                btree_destroy(&sh_info->pagemap);
-                free(sh_info);
-        }
+        panic("Inconsistency detected while removing %zu pages of used "
+            "space from %p.", count, (void *) page);
 }
 
@@ -1893 +2000 @@
 
 /** 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,
@@ -1903 +2010 @@
 
 /** 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);
@@ -1909 +2016 @@
 
 /** 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);
@@ -1922 +2029 @@
 /** 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;
+        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();
         mutex_lock(&as->lock);
         
@@ -2001 +2097 @@
         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
-                            " (%p - %p)\n", area, area->base, area->pages,
-                            area->base, area->base + FRAMES2SIZE(area->pages));
+                        printf("as_area: %p, base=%p, pages=%zu"
+                            " (%p - %p)\n", area, (void *) area->base,
+                            area->pages, (void *) area->base,
+                            (void *) (area->base + FRAMES2SIZE(area->pages)));
                         mutex_unlock(&area->lock);
                 }
@@ -2018 +2114 @@
         
         mutex_unlock(&as->lock);
-        interrupts_restore(ipl);
 }
 

kernel/generic/src/mm/backend_anon.c

@@ -47 +47 @@
 #include <adt/btree.h>
 #include <errno.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <align.h>
 #include <arch.h>
@@ -79 +79 @@
 {
         uintptr_t frame;
+
+        ASSERT(page_table_locked(AS));
+        ASSERT(mutex_locked(&area->lock));
 
         if (!as_area_check_access(area, access))
@@ -168 +171 @@
 void anon_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
 {
+        ASSERT(page_table_locked(area->as));
+        ASSERT(mutex_locked(&area->lock));
+
         frame_free(frame);
 }
@@ -183 +189 @@
 {
         link_t *cur;
+
+        ASSERT(mutex_locked(&area->as->lock));
+        ASSERT(mutex_locked(&area->lock));
 
         /*

kernel/generic/src/mm/backend_elf.c

@@ -38 +38 @@
 #include <lib/elf.h>
 #include <debug.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <mm/as.h>
 #include <mm/frame.h>
@@ -85 +85 @@
         size_t i;
         bool dirty = false;
+
+        ASSERT(page_table_locked(AS));
+        ASSERT(mutex_locked(&area->lock));
 
         if (!as_area_check_access(area, access))
@@ -232 +235 @@
 void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
 {
-        elf_header_t *elf = area->backend_data.elf;
         elf_segment_header_t *entry = area->backend_data.segment;
-        uintptr_t base, start_anon;
-        size_t i;
-
-        ASSERT((page >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) &&
-            (page < entry->p_vaddr + entry->p_memsz));
-        i = (page - ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) >> PAGE_WIDTH;
-        base = (uintptr_t) (((void *) elf) +
-            ALIGN_DOWN(entry->p_offset, FRAME_SIZE));
+        uintptr_t start_anon;
+
+        ASSERT(page_table_locked(area->as));
+        ASSERT(mutex_locked(&area->lock));
+
+        ASSERT(page >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE));
+        ASSERT(page < entry->p_vaddr + entry->p_memsz);
+
         start_anon = entry->p_vaddr + entry->p_filesz;
 
@@ -257 +259 @@
                  * lower part is backed by the ELF image and the upper is
                  * anonymous). In any case, a frame needs to be freed.
-                 */ 
+                 */
                 frame_free(frame);
         }
@@ -267 +269 @@
  * Otherwise only portions of the area that are not backed by the ELF image
  * are put into the pagemap.
- *
- * The address space and address space area must be locked prior to the call.
  *
  * @param area          Address space area.
@@ -278 +278 @@
         btree_node_t *leaf, *node;
         uintptr_t start_anon = entry->p_vaddr + entry->p_filesz;
+
+        ASSERT(mutex_locked(&area->as->lock));
+        ASSERT(mutex_locked(&area->lock));
 
         /*

kernel/generic/src/mm/backend_phys.c

@@ -38 +38 @@
 
 #include <debug.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <mm/as.h>
 #include <mm/page.h>
@@ -72 +72 @@
         uintptr_t base = area->backend_data.base;
 
+        ASSERT(page_table_locked(AS));
+        ASSERT(mutex_locked(&area->lock));
+
         if (!as_area_check_access(area, access))
                 return AS_PF_FAULT;
@@ -93 +96 @@
 void phys_share(as_area_t *area)
 {
+        ASSERT(mutex_locked(&area->as->lock));
+        ASSERT(mutex_locked(&area->lock));
 }
 

kernel/generic/src/mm/buddy.c

@@ -41 +41 @@
 #include <mm/buddy.h>
 #include <mm/frame.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <debug.h>
 #include <print.h>

kernel/generic/src/mm/frame.c

@@ -43 +43 @@
  */
 
-#include <arch/types.h>
+#include <typedefs.h>
 #include <mm/frame.h>
 #include <mm/as.h>
@@ -66 +66 @@
  * available.
  */
-mutex_t mem_avail_mtx;
-condvar_t mem_avail_cv;
-size_t mem_avail_req = 0;  /**< Number of frames requested. */
-size_t mem_avail_gen = 0;  /**< Generation counter. */
+static mutex_t mem_avail_mtx;
+static condvar_t mem_avail_cv;
+static size_t mem_avail_req = 0;  /**< Number of frames requested. */
+static size_t mem_avail_gen = 0;  /**< Generation counter. */
 
 /********************/
@@ -75 +75 @@
 /********************/
 
-static inline size_t frame_index(zone_t *zone, frame_t *frame)
+NO_TRACE static inline size_t frame_index(zone_t *zone, frame_t *frame)
 {
         return (size_t) (frame - zone->frames);
 }
 
-static inline size_t frame_index_abs(zone_t *zone, frame_t *frame)
+NO_TRACE static inline size_t frame_index_abs(zone_t *zone, frame_t *frame)
 {
         return (size_t) (frame - zone->frames) + zone->base;
 }
 
-static inline bool frame_index_valid(zone_t *zone, size_t index)
+NO_TRACE static inline bool frame_index_valid(zone_t *zone, size_t index)
 {
         return (index < zone->count);
 }
 
-static inline size_t make_frame_index(zone_t *zone, frame_t *frame)
+NO_TRACE static inline size_t make_frame_index(zone_t *zone, frame_t *frame)
 {
         return (frame - zone->frames);
@@ -100 +100 @@
  *
  */
-static void frame_initialize(frame_t *frame)
+NO_TRACE static void frame_initialize(frame_t *frame)
 {
         frame->refcount = 1;
@@ -121 +121 @@
  *
  */
-static size_t zones_insert_zone(pfn_t base, size_t count)
+NO_TRACE static size_t zones_insert_zone(pfn_t base, size_t count,
+    zone_flags_t flags)
 {
         if (zones.count + 1 == ZONES_MAX) {
@@ -131 +132 @@
         for (i = 0; i < zones.count; i++) {
                 /* Check for overlap */
-                if (overlaps(base, count,
-                    zones.info[i].base, zones.info[i].count)) {
-                        printf("Zones overlap!\n");
+                if (overlaps(zones.info[i].base, zones.info[i].count,
+                    base, count)) {
+                        
+                        /*
+                         * If the overlaping zones are of the same type
+                         * and the new zone is completely within the previous
+                         * one, then quietly ignore the new zone.
+                         *
+                         */
+                        
+                        if ((zones.info[i].flags != flags) ||
+                            (!iswithin(zones.info[i].base, zones.info[i].count,
+                            base, count))) {
+                                printf("Zone (%p, %p) overlaps "
+                                    "with previous zone (%p %p)!\n",
+                                    (void *) PFN2ADDR(base), (void *) PFN2ADDR(count),
+                                    (void *) PFN2ADDR(zones.info[i].base),
+                                    (void *) PFN2ADDR(zones.info[i].count));
+                        }
+                        
                         return (size_t) -1;
                 }
@@ -144 +162 @@
         for (j = zones.count; j > i; j--) {
                 zones.info[j] = zones.info[j - 1];
-                zones.info[j].buddy_system->data =
-                    (void *) &zones.info[j - 1];
+                if (zones.info[j].buddy_system != NULL)
+                        zones.info[j].buddy_system->data =
+                            (void *) &zones.info[j];
         }
         
@@ -162 +181 @@
  */
 #ifdef CONFIG_DEBUG
-static size_t total_frames_free(void)
+NO_TRACE static size_t total_frames_free(void)
 {
         size_t total = 0;
@@ -171 +190 @@
         return total;
 }
-#endif
+#endif /* CONFIG_DEBUG */
 
 /** Find a zone with a given frames.
@@ -185 +204 @@
  *
  */
-size_t find_zone(pfn_t frame, size_t count, size_t hint)
+NO_TRACE size_t find_zone(pfn_t frame, size_t count, size_t hint)
 {
         if (hint >= zones.count)
@@ -199 +218 @@
                 if (i >= zones.count)
                         i = 0;
+                
         } while (i != hint);
         
@@ -205 +225 @@
 
 /** @return True if zone can allocate specified order */
-static bool zone_can_alloc(zone_t *zone, uint8_t order)
+NO_TRACE static bool zone_can_alloc(zone_t *zone, uint8_t order)
 {
         return (zone_flags_available(zone->flags)
@@ -221 +241 @@
  *
  */
-static size_t find_free_zone(uint8_t order, zone_flags_t flags, size_t hint)
+NO_TRACE static size_t find_free_zone(uint8_t order, zone_flags_t flags,
+    size_t hint)
 {
         if (hint >= zones.count)
@@ -242 +263 @@
                 if (i >= zones.count)
                         i = 0;
+                
         } while (i != hint);
         
@@ -260 +282 @@
  *
  */
-static link_t *zone_buddy_find_block(buddy_system_t *buddy, link_t *child,
-    uint8_t order)
+NO_TRACE static link_t *zone_buddy_find_block(buddy_system_t *buddy,
+    link_t *child, uint8_t order)
 {
         frame_t *frame = list_get_instance(child, frame_t, buddy_link);
@@ -283 +305 @@
  *
  */
-static link_t *zone_buddy_find_buddy(buddy_system_t *buddy, link_t *block) 
+NO_TRACE static link_t *zone_buddy_find_buddy(buddy_system_t *buddy,
+    link_t *block)
 {
         frame_t *frame = list_get_instance(block, frame_t, buddy_link);
@@ -296 +319 @@
                 index = (frame_index(zone, frame)) +
                     (1 << frame->buddy_order);
-        } else {        /* is_right */
+        } else {  /* is_right */
                 index = (frame_index(zone, frame)) -
                     (1 << frame->buddy_order);
@@ -319 +342 @@
  *
  */
-static link_t *zone_buddy_bisect(buddy_system_t *buddy, link_t *block)
+NO_TRACE static link_t *zone_buddy_bisect(buddy_system_t *buddy, link_t *block)
 {
         frame_t *frame_l = list_get_instance(block, frame_t, buddy_link);
@@ -337 +360 @@
  *
  */
-static link_t *zone_buddy_coalesce(buddy_system_t *buddy, link_t *block_1,
-    link_t *block_2)
+NO_TRACE static link_t *zone_buddy_coalesce(buddy_system_t *buddy,
+    link_t *block_1, link_t *block_2)
 {
         frame_t *frame1 = list_get_instance(block_1, frame_t, buddy_link);
@@ -353 +376 @@
  *
  */
-static void zone_buddy_set_order(buddy_system_t *buddy, link_t *block,
+NO_TRACE static void zone_buddy_set_order(buddy_system_t *buddy, link_t *block,
     uint8_t order)
 {
@@ -367 +390 @@
  *
  */
-static uint8_t zone_buddy_get_order(buddy_system_t *buddy, link_t *block)
+NO_TRACE static uint8_t zone_buddy_get_order(buddy_system_t *buddy,
+    link_t *block)
 {
         return list_get_instance(block, frame_t, buddy_link)->buddy_order;
@@ -378 +402 @@
  *
  */
-static void zone_buddy_mark_busy(buddy_system_t *buddy, link_t * block)
+NO_TRACE static void zone_buddy_mark_busy(buddy_system_t *buddy, link_t *block)
 {
         list_get_instance(block, frame_t, buddy_link)->refcount = 1;
@@ -387 +411 @@
  * @param buddy Buddy system.
  * @param block Buddy system block.
- */
-static void zone_buddy_mark_available(buddy_system_t *buddy, link_t *block)
+ *
+ */
+NO_TRACE static void zone_buddy_mark_available(buddy_system_t *buddy,
+    link_t *block)
 {
         list_get_instance(block, frame_t, buddy_link)->refcount = 0;
@@ -419 +445 @@
  *
  */
-static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
+NO_TRACE static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
 {
         ASSERT(zone_flags_available(zone->flags));
@@ -447 +473 @@
  *
  */
-static void zone_frame_free(zone_t *zone, size_t frame_idx)
+NO_TRACE static void zone_frame_free(zone_t *zone, size_t frame_idx)
 {
         ASSERT(zone_flags_available(zone->flags));
@@ -468 +494 @@
 
 /** Return frame from zone. */
-static frame_t *zone_get_frame(zone_t *zone, size_t frame_idx)
+NO_TRACE static frame_t *zone_get_frame(zone_t *zone, size_t frame_idx)
 {
         ASSERT(frame_idx < zone->count);
@@ -475 +501 @@
 
 /** Mark frame in zone unavailable to allocation. */
-static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)
+NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)
 {
         ASSERT(zone_flags_available(zone->flags));
@@ -504 +530 @@
  *
  */
-static void zone_merge_internal(size_t z1, size_t z2, zone_t *old_z1, buddy_system_t *buddy)
+NO_TRACE static void zone_merge_internal(size_t z1, size_t z2, zone_t *old_z1,
+    buddy_system_t *buddy)
 {
         ASSERT(zone_flags_available(zones.info[z1].flags));
@@ -600 +627 @@
  *
  */
-static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
+NO_TRACE static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
 {
         ASSERT(zone_flags_available(zones.info[znum].flags));
@@ -635 +662 @@
  *
  */
-static void zone_reduce_region(size_t znum, pfn_t frame_idx, size_t count)
+NO_TRACE static void zone_reduce_region(size_t znum, pfn_t frame_idx,
+    size_t count)
 {
         ASSERT(zone_flags_available(zones.info[znum].flags));
@@ -673 +701 @@
 bool zone_merge(size_t z1, size_t z2)
 {
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&zones.lock);
+        irq_spinlock_lock(&zones.lock, true);
         
         bool ret = true;
@@ -737 +764 @@
         for (i = z2 + 1; i < zones.count; i++) {
                 zones.info[i - 1] = zones.info[i];
-                zones.info[i - 1].buddy_system->data =
-                    (void *) &zones.info[i - 1];
+                if (zones.info[i - 1].buddy_system != NULL)
+                        zones.info[i - 1].buddy_system->data =
+                            (void *) &zones.info[i - 1];
         }
         
@@ -744 +772 @@
         
 errout:
-        spinlock_unlock(&zones.lock);
-        interrupts_restore(ipl);
+        irq_spinlock_unlock(&zones.lock, true);
         
         return ret;
@@ -777 +804 @@
  *
  */
-static void zone_construct(zone_t *zone, buddy_system_t *buddy, pfn_t start, size_t count, zone_flags_t flags)
+NO_TRACE static void zone_construct(zone_t *zone, buddy_system_t *buddy,
+    pfn_t start, size_t count, zone_flags_t flags)
 {
         zone->base = start;
@@ -820 +848 @@
  *
  */
-uintptr_t zone_conf_size(size_t count)
+size_t zone_conf_size(size_t count)
 {
         return (count * sizeof(frame_t) + buddy_conf_size(fnzb(count)));
@@ -841 +869 @@
  *
  */
-size_t zone_create(pfn_t start, size_t count, pfn_t confframe, zone_flags_t flags)
-{
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&zones.lock);
+size_t zone_create(pfn_t start, size_t count, pfn_t confframe,
+    zone_flags_t flags)
+{
+        irq_spinlock_lock(&zones.lock, true);
         
         if (zone_flags_available(flags)) {  /* Create available zone */
@@ -851 +879 @@
                  * the assert
                  */
-                ASSERT(confframe != NULL);
+                ASSERT(confframe != ADDR2PFN((uintptr_t ) NULL));
                 
                 /* If confframe is supposed to be inside our zone, then make sure
@@ -887 +915 @@
                 }
                 
-                size_t znum = zones_insert_zone(start, count);
+                size_t znum = zones_insert_zone(start, count, flags);
                 if (znum == (size_t) -1) {
-                        spinlock_unlock(&zones.lock);
-                        interrupts_restore(ipl);
+                        irq_spinlock_unlock(&zones.lock, true);
                         return (size_t) -1;
                 }
@@ -905 +932 @@
                 }
                 
-                spinlock_unlock(&zones.lock);
-                interrupts_restore(ipl);
+                irq_spinlock_unlock(&zones.lock, true);
                 
                 return znum;
@@ -912 +938 @@
         
         /* Non-available zone */
-        size_t znum = zones_insert_zone(start, count);
+        size_t znum = zones_insert_zone(start, count, flags);
         if (znum == (size_t) -1) {
-                spinlock_unlock(&zones.lock);
-                interrupts_restore(ipl);
+                irq_spinlock_unlock(&zones.lock, true);
                 return (size_t) -1;
         }
         zone_construct(&zones.info[znum], NULL, start, count, flags);
         
-        spinlock_unlock(&zones.lock);
-        interrupts_restore(ipl);
+        irq_spinlock_unlock(&zones.lock, true);
         
         return znum;
@@ -933 +957 @@
 void frame_set_parent(pfn_t pfn, void *data, size_t hint)
 {
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&zones.lock);
+        irq_spinlock_lock(&zones.lock, true);
         
         size_t znum = find_zone(pfn, 1, hint);
@@ -943 +966 @@
             pfn - zones.info[znum].base)->parent = data;
         
-        spinlock_unlock(&zones.lock);
-        interrupts_restore(ipl);
+        irq_spinlock_unlock(&zones.lock, true);
 }
 
 void *frame_get_parent(pfn_t pfn, size_t hint)
 {
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&zones.lock);
+        irq_spinlock_lock(&zones.lock, true);
         
         size_t znum = find_zone(pfn, 1, hint);
@@ -959 +980 @@
             pfn - zones.info[znum].base)->parent;
         
-        spinlock_unlock(&zones.lock);
-        interrupts_restore(ipl);
+        irq_spinlock_unlock(&zones.lock, true);
         
         return res;
@@ -977 +997 @@
 {
         size_t size = ((size_t) 1) << order;
-        ipl_t ipl;
         size_t hint = pzone ? (*pzone) : 0;
         
 loop:
-        ipl = interrupts_disable();
-        spinlock_lock(&zones.lock);
+        irq_spinlock_lock(&zones.lock, true);
         
         /*
@@ -993 +1011 @@
            if it does not help, reclaim all */
         if ((znum == (size_t) -1) && (!(flags & FRAME_NO_RECLAIM))) {
-                spinlock_unlock(&zones.lock);
-                interrupts_restore(ipl);
-                
+                irq_spinlock_unlock(&zones.lock, true);
                 size_t freed = slab_reclaim(0);
-                
-                ipl = interrupts_disable();
-                spinlock_lock(&zones.lock);
+                irq_spinlock_lock(&zones.lock, true);
                 
                 if (freed > 0)
@@ -1006 +1020 @@
                 
                 if (znum == (size_t) -1) {
-                        spinlock_unlock(&zones.lock);
-                        interrupts_restore(ipl);
-                        
+                        irq_spinlock_unlock(&zones.lock, true);
                         freed = slab_reclaim(SLAB_RECLAIM_ALL);
-                        
-                        ipl = interrupts_disable();
-                        spinlock_lock(&zones.lock);
+                        irq_spinlock_lock(&zones.lock, true);
                         
                         if (freed > 0)
@@ -1022 +1032 @@
         if (znum == (size_t) -1) {
                 if (flags & FRAME_ATOMIC) {
-                        spinlock_unlock(&zones.lock);
-                        interrupts_restore(ipl);
+                        irq_spinlock_unlock(&zones.lock, true);
                         return NULL;
                 }
@@ -1031 +1040 @@
 #endif
                 
-                spinlock_unlock(&zones.lock);
-                interrupts_restore(ipl);
+                irq_spinlock_unlock(&zones.lock, true);
+                
+                if (!THREAD)
+                        panic("Cannot wait for memory to become available.");
                 
                 /*
@@ -1039 +1050 @@
                 
 #ifdef CONFIG_DEBUG
-                printf("Thread %" PRIu64 " waiting for %" PRIs " frames, "
-                    "%" PRIs " available.\n", THREAD->tid, size, avail);
+                printf("Thread %" PRIu64 " waiting for %zu frames, "
+                    "%zu available.\n", THREAD->tid, size, avail);
 #endif
                 
@@ -1066 +1077 @@
             + zones.info[znum].base;
         
-        spinlock_unlock(&zones.lock);
-        interrupts_restore(ipl);
+        irq_spinlock_unlock(&zones.lock, true);
         
         if (pzone)
@@ -1089 +1099 @@
 void frame_free(uintptr_t frame)
 {
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&zones.lock);
+        irq_spinlock_lock(&zones.lock, true);
         
         /*
@@ -1096 +1105 @@
          */
         pfn_t pfn = ADDR2PFN(frame);
-        size_t znum = find_zone(pfn, 1, NULL);
+        size_t znum = find_zone(pfn, 1, 0);
         
         ASSERT(znum != (size_t) -1);
@@ -1102 +1111 @@
         zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
         
-        spinlock_unlock(&zones.lock);
-        interrupts_restore(ipl);
+        irq_spinlock_unlock(&zones.lock, true);
         
         /*
@@ -1127 +1135 @@
  *
  */
-void frame_reference_add(pfn_t pfn)
-{
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&zones.lock);
+NO_TRACE void frame_reference_add(pfn_t pfn)
+{
+        irq_spinlock_lock(&zones.lock, true);
         
         /*
          * First, find host frame zone for addr.
          */
-        size_t znum = find_zone(pfn, 1, NULL);
+        size_t znum = find_zone(pfn, 1, 0);
         
         ASSERT(znum != (size_t) -1);
@@ -1141 +1148 @@
         zones.info[znum].frames[pfn - zones.info[znum].base].refcount++;
         
-        spinlock_unlock(&zones.lock);
-        interrupts_restore(ipl);
-}
-
-/** Mark given range unavailable in frame zones. */
-void frame_mark_unavailable(pfn_t start, size_t count)
-{
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&zones.lock);
+        irq_spinlock_unlock(&zones.lock, true);
+}
+
+/** Mark given range unavailable in frame zones.
+ *
+ */
+NO_TRACE void frame_mark_unavailable(pfn_t start, size_t count)
+{
+        irq_spinlock_lock(&zones.lock, true);
         
         size_t i;
@@ -1161 +1168 @@
         }
         
-        spinlock_unlock(&zones.lock);
-        interrupts_restore(ipl);
-}
-
-/** Initialize physical memory management. */
+        irq_spinlock_unlock(&zones.lock, true);
+}
+
+/** Initialize physical memory management.
+ *
+ */
 void frame_init(void)
 {
         if (config.cpu_active == 1) {
                 zones.count = 0;
-                spinlock_initialize(&zones.lock, "zones.lock");
+                irq_spinlock_initialize(&zones.lock, "frame.zones.lock");
                 mutex_initialize(&mem_avail_mtx, MUTEX_ACTIVE);
                 condvar_initialize(&mem_avail_cv);
@@ -1201 +1209 @@
 }
 
-/** Return total size of all zones. */
-uint64_t zone_total_size(void)
-{
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&zones.lock);
+/** Return total size of all zones.
+ *
+ */
+uint64_t zones_total_size(void)
+{
+        irq_spinlock_lock(&zones.lock, true);
         
         uint64_t total = 0;
@@ -1212 +1221 @@
                 total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
         
-        spinlock_unlock(&zones.lock);
-        interrupts_restore(ipl);
+        irq_spinlock_unlock(&zones.lock, true);
         
         return total;
 }
 
-/** Prints list of zones. */
-void zone_print_list(void)
+void zones_stats(uint64_t *total, uint64_t *unavail, uint64_t *busy,
+    uint64_t *free)
+{
+        ASSERT(total != NULL);
+        ASSERT(unavail != NULL);
+        ASSERT(busy != NULL);
+        ASSERT(free != NULL);
+        
+        irq_spinlock_lock(&zones.lock, true);
+        
+        *total = 0;
+        *unavail = 0;
+        *busy = 0;
+        *free = 0;
+        
+        size_t i;
+        for (i = 0; i < zones.count; i++) {
+                *total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
+                
+                if (zone_flags_available(zones.info[i].flags)) {
+                        *busy += (uint64_t) FRAMES2SIZE(zones.info[i].busy_count);
+                        *free += (uint64_t) FRAMES2SIZE(zones.info[i].free_count);
+                } else
+                        *unavail += (uint64_t) FRAMES2SIZE(zones.info[i].count);
+        }
+        
+        irq_spinlock_unlock(&zones.lock, true);
+}
+
+/** Prints list of zones.
+ *
+ */
+void zones_print_list(void)
 {
 #ifdef __32_BITS__
-        printf("#  base address frames       flags    free frames  busy frames\n");
-        printf("-- ------------ ------------ -------- ------------ ------------\n");
+        printf("[nr] [base addr] [frames    ] [flags ] [free frames ] [busy frames ]\n");
 #endif
 
 #ifdef __64_BITS__
-        printf("#  base address          frames      flags    free frames  busy frames\n");
-        printf("-- -------------------- ------------ -------- ------------ ------------\n");
+        printf("[nr] [base address    ] [frames    ] [flags ] [free frames ] [busy frames ]\n");
 #endif
         
@@ -1244 +1281 @@
         size_t i;
         for (i = 0;; i++) {
-                ipl_t ipl = interrupts_disable();
-                spinlock_lock(&zones.lock);
+                irq_spinlock_lock(&zones.lock, true);
                 
                 if (i >= zones.count) {
-                        spinlock_unlock(&zones.lock);
-                        interrupts_restore(ipl);
+                        irq_spinlock_unlock(&zones.lock, true);
                         break;
                 }
@@ -1259 +1294 @@
                 size_t busy_count = zones.info[i].busy_count;
                 
-                spinlock_unlock(&zones.lock);
-                interrupts_restore(ipl);
+                irq_spinlock_unlock(&zones.lock, true);
                 
                 bool available = zone_flags_available(flags);
                 
-                printf("%-2" PRIs, i);
+                printf("%-4zu", i);
                 
 #ifdef __32_BITS__
-                printf("   %10p", base);
+                printf("  %p", (void *) base);
 #endif
                 
 #ifdef __64_BITS__
-                printf("   %18p", base);
+                printf(" %p", (void *) base);
 #endif
                 
-                printf(" %12" PRIs " %c%c%c      ", count,
+                printf(" %12zu %c%c%c      ", count,
                     available ? 'A' : ' ',
                     (flags & ZONE_RESERVED) ? 'R' : ' ',
@@ -1280 +1314 @@
                 
                 if (available)
-                        printf("%12" PRIs " %12" PRIs,
+                        printf("%14zu %14zu",
                             free_count, busy_count);
                 
@@ -1294 +1328 @@
 void zone_print_one(size_t num)
 {
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&zones.lock);
+        irq_spinlock_lock(&zones.lock, true);
         size_t znum = (size_t) -1;
         
@@ -1307 +1340 @@
         
         if (znum == (size_t) -1) {
-                spinlock_unlock(&zones.lock);
-                interrupts_restore(ipl);
+                irq_spinlock_unlock(&zones.lock, true);
                 printf("Zone not found.\n");
                 return;
@@ -1319 +1351 @@
         size_t busy_count = zones.info[i].busy_count;
         
-        spinlock_unlock(&zones.lock);
-        interrupts_restore(ipl);
+        irq_spinlock_unlock(&zones.lock, true);
         
         bool available = zone_flags_available(flags);
         
-        printf("Zone number:       %" PRIs "\n", znum);
-        printf("Zone base address: %p\n", base);
-        printf("Zone size:         %" PRIs " frames (%" PRIs " KiB)\n", count,
+        printf("Zone number:       %zu\n", znum);
+        printf("Zone base address: %p\n", (void *) base);
+        printf("Zone size:         %zu frames (%zu KiB)\n", count,
             SIZE2KB(FRAMES2SIZE(count)));
         printf("Zone flags:        %c%c%c\n",
@@ -1334 +1365 @@
         
         if (available) {
-                printf("Allocated space:   %" PRIs " frames (%" PRIs " KiB)\n",
+                printf("Allocated space:   %zu frames (%zu KiB)\n",
                     busy_count, SIZE2KB(FRAMES2SIZE(busy_count)));
-                printf("Available space:   %" PRIs " frames (%" PRIs " KiB)\n",
+                printf("Available space:   %zu frames (%zu KiB)\n",
                     free_count, SIZE2KB(FRAMES2SIZE(free_count)));
         }

kernel/generic/src/mm/page.c

@@ -33 +33 @@
 /**
  * @file
- * @brief       Virtual Address Translation subsystem.
+ * @brief Virtual Address Translation subsystem.
  *
  * This file contains code for creating, destroying and searching
  * mappings between virtual addresses and physical addresses.
  * Functions here are mere wrappers that call the real implementation.
- * They however, define the single interface. 
+ * They however, define the single interface.
+ *
  */
 
@@ -55 +56 @@
  * will do an implicit serialization by virtue of running the TLB shootdown
  * interrupt handler.
+ *
  */
 
@@ -63 +65 @@
 #include <mm/frame.h>
 #include <arch/barrier.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <arch/asm.h>
 #include <memstr.h>
@@ -83 +85 @@
  * of page boundaries.
  *
- * @param s             Address of the structure.
- * @param size          Size of the structure.
+ * @param addr Address of the structure.
+ * @param size Size of the structure.
+ *
  */
-void map_structure(uintptr_t s, size_t size)
+void map_structure(uintptr_t addr, size_t size)
 {
-        int i, cnt, length;
-
-        length = size + (s - (s & ~(PAGE_SIZE - 1)));
-        cnt = length / PAGE_SIZE + (length % PAGE_SIZE > 0);
-
+        size_t length = size + (addr - (addr & ~(PAGE_SIZE - 1)));
+        size_t cnt = length / PAGE_SIZE + (length % PAGE_SIZE > 0);
+        
+        size_t i;
         for (i = 0; i < cnt; i++)
-                page_mapping_insert(AS_KERNEL, s + i * PAGE_SIZE,
-                    s + i * PAGE_SIZE, PAGE_NOT_CACHEABLE | PAGE_WRITE);
-
+                page_mapping_insert(AS_KERNEL, addr + i * PAGE_SIZE,
+                    addr + i * PAGE_SIZE, PAGE_NOT_CACHEABLE | PAGE_WRITE);
+        
         /* Repel prefetched accesses to the old mapping. */
         memory_barrier();
@@ -106 +108 @@
  * using flags. Allocate and setup any missing page tables.
  *
- * The page table must be locked and interrupts must be disabled.
+ * @param as    Address space to wich page belongs.
+ * @param page  Virtual address of the page to be mapped.
+ * @param frame Physical address of memory frame to which the mapping is
+ *              done.
+ * @param flags Flags to be used for mapping.
  *
- * @param as            Address space to wich page belongs.
- * @param page          Virtual address of the page to be mapped.
- * @param frame         Physical address of memory frame to which the mapping is
- *                      done.
- * @param flags         Flags to be used for mapping.
  */
-void page_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame, int flags)
+NO_TRACE void page_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame,
+    unsigned int flags)
 {
+        ASSERT(page_table_locked(as));
+        
         ASSERT(page_mapping_operations);
         ASSERT(page_mapping_operations->mapping_insert);
-        
+
         page_mapping_operations->mapping_insert(as, page, frame, flags);
         
@@ -131 +135 @@
  * this call visible.
  *
- * The page table must be locked and interrupts must be disabled.
+ * @param as   Address space to wich page belongs.
+ * @param page Virtual address of the page to be demapped.
  *
- * @param as            Address space to wich page belongs.
- * @param page          Virtual address of the page to be demapped.
  */
-void page_mapping_remove(as_t *as, uintptr_t page)
+NO_TRACE void page_mapping_remove(as_t *as, uintptr_t page)
 {
+        ASSERT(page_table_locked(as));
+        
         ASSERT(page_mapping_operations);
         ASSERT(page_mapping_operations->mapping_remove);
         
         page_mapping_operations->mapping_remove(as, page);
-
+        
         /* Repel prefetched accesses to the old mapping. */
         memory_barrier();
@@ -151 +156 @@
  * Find mapping for virtual page.
  *
- * The page table must be locked and interrupts must be disabled.
+ * @param as   Address space to wich page belongs.
+ * @param page Virtual page.
  *
- * @param as            Address space to wich page belongs.
- * @param page          Virtual page.
+ * @return NULL if there is no such mapping; requested mapping
+ *         otherwise.
  *
- * @return              NULL if there is no such mapping; requested mapping
- *                      otherwise.
  */
-pte_t *page_mapping_find(as_t *as, uintptr_t page)
+NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page)
 {
+        ASSERT(page_table_locked(as));
+        
         ASSERT(page_mapping_operations);
         ASSERT(page_mapping_operations->mapping_find);
-
+        
         return page_mapping_operations->mapping_find(as, page);
 }

kernel/generic/src/mm/slab.c

@@ -33 +33 @@
 /**
  * @file
- * @brief       Slab allocator.
+ * @brief Slab allocator.
  *
  * The slab allocator is closely modelled after OpenSolaris slab allocator.
@@ -50 +50 @@
  *
  * The slab allocator supports per-CPU caches ('magazines') to facilitate
- * good SMP scaling. 
+ * good SMP scaling.
  *
  * When a new object is being allocated, it is first checked, if it is 
@@ -65 +65 @@
  * thrashing when somebody is allocating/deallocating 1 item at the magazine
  * size boundary. LIFO order is enforced, which should avoid fragmentation
- * as much as possible. 
- *  
+ * as much as possible.
+ *
  * Every cache contains list of full slabs and list of partially full slabs.
  * Empty slabs are immediately freed (thrashing will be avoided because
- * of magazines). 
+ * of magazines).
  *
  * The slab information structure is kept inside the data area, if possible.
@@ -95 +95 @@
  *
  * @todo
- * it might be good to add granularity of locks even to slab level,
+ * It might be good to add granularity of locks even to slab level,
  * we could then try_spinlock over all partial slabs and thus improve
- * scalability even on slab level
+ * scalability even on slab level.
+ *
  */
 
@@ -114 +115 @@
 #include <macros.h>
 
-SPINLOCK_INITIALIZE(slab_cache_lock);
+IRQ_SPINLOCK_STATIC_INITIALIZE(slab_cache_lock);
 static LIST_INITIALIZE(slab_cache_list);
 
 /** Magazine cache */
 static slab_cache_t mag_cache;
+
 /** Cache for cache descriptors */
 static slab_cache_t slab_cache_cache;
+
 /** Cache for external slab descriptors
  * This time we want per-cpu cache, so do not make it static
@@ -128 +131 @@
  */
 static slab_cache_t *slab_extern_cache;
+
 /** Caches for malloc */
 static slab_cache_t *malloc_caches[SLAB_MAX_MALLOC_W - SLAB_MIN_MALLOC_W + 1];
-static char *malloc_names[] =  {
+
+static const char *malloc_names[] =  {
         "malloc-16",
         "malloc-32",
@@ -154 +159 @@
 /** Slab descriptor */
 typedef struct {
-        slab_cache_t *cache;    /**< Pointer to parent cache. */
-        link_t link;            /**< List of full/partial slabs. */
-        void *start;            /**< Start address of first available item. */
-        size_t available;       /**< Count of available items in this slab. */
-        size_t nextavail;       /**< The index of next available item. */
+        slab_cache_t *cache;  /**< Pointer to parent cache. */
+        link_t link;          /**< List of full/partial slabs. */
+        void *start;          /**< Start address of first available item. */
+        size_t available;     /**< Count of available items in this slab. */
+        size_t nextavail;     /**< The index of next available item. */
 } slab_t;
 
 #ifdef CONFIG_DEBUG
-static int _slab_initialized = 0;
+static unsigned int _slab_initialized = 0;
 #endif
 
 /**************************************/
 /* Slab allocation functions          */
-
-/**
- * Allocate frames for slab space and initialize
- *
- */
-static slab_t *slab_space_alloc(slab_cache_t *cache, int flags)
-{
-        void *data;
+/**************************************/
+
+/** Allocate frames for slab space and initialize
+ *
+ */
+NO_TRACE static slab_t *slab_space_alloc(slab_cache_t *cache,
+    unsigned int flags)
+{
+        
+        
+        size_t zone = 0;
+        
+        void *data = frame_alloc_generic(cache->order, FRAME_KA | flags, &zone);
+        if (!data) {
+                return NULL;
+        }
+        
         slab_t *slab;
         size_t fsize;
-        unsigned int i;
-        size_t zone = 0;
-        
-        data = frame_alloc_generic(cache->order, FRAME_KA | flags, &zone);
-        if (!data) {
-                return NULL;
-        }
+        
         if (!(cache->flags & SLAB_CACHE_SLINSIDE)) {
                 slab = slab_alloc(slab_extern_cache, flags);
@@ -196 +204 @@
         
         /* Fill in slab structures */
-        for (i = 0; i < ((unsigned int) 1 << cache->order); i++)
+        size_t i;
+        for (i = 0; i < ((size_t) 1 << cache->order); i++)
                 frame_set_parent(ADDR2PFN(KA2PA(data)) + i, slab, zone);
-
+        
         slab->start = data;
         slab->available = cache->objects;
         slab->nextavail = 0;
         slab->cache = cache;
-
+        
         for (i = 0; i < cache->objects; i++)
-                *((int *) (slab->start + i*cache->size)) = i + 1;
-
+                *((size_t *) (slab->start + i * cache->size)) = i + 1;
+        
         atomic_inc(&cache->allocated_slabs);
         return slab;
 }
 
-/**
- * Deallocate space associated with slab
+/** Deallocate space associated with slab
  *
  * @return number of freed frames
- */
-static size_t slab_space_free(slab_cache_t *cache, slab_t *slab)
+ *
+ */
+NO_TRACE static size_t slab_space_free(slab_cache_t *cache, slab_t *slab)
 {
         frame_free(KA2PA(slab->start));
-        if (! (cache->flags & SLAB_CACHE_SLINSIDE))
+        if (!(cache->flags & SLAB_CACHE_SLINSIDE))
                 slab_free(slab_extern_cache, slab);
-
+        
         atomic_dec(&cache->allocated_slabs);
         
-        return 1 << cache->order;
+        return (1 << cache->order);
 }
 
 /** Map object to slab structure */
-static slab_t * obj2slab(void *obj)
+NO_TRACE static slab_t *obj2slab(void *obj)
 {
         return (slab_t *) frame_get_parent(ADDR2PFN(KA2PA(obj)), 0);
 }
 
-/**************************************/
+/******************/
 /* Slab functions */
-
-
-/**
- * Return object to slab and call a destructor
+/******************/
+
+/** Return object to slab and call a destructor
  *
  * @param slab If the caller knows directly slab of the object, otherwise NULL
  *
  * @return Number of freed pages
- */
-static size_t slab_obj_destroy(slab_cache_t *cache, void *obj, slab_t *slab)
-{
-        int freed = 0;
-
+ *
+ */
+NO_TRACE static size_t slab_obj_destroy(slab_cache_t *cache, void *obj,
+    slab_t *slab)
+{
         if (!slab)
                 slab = obj2slab(obj);
-
+        
         ASSERT(slab->cache == cache);
-
+        
+        size_t freed = 0;
+        
         if (cache->destructor)
                 freed = cache->destructor(obj);
@@ -258 +268 @@
         spinlock_lock(&cache->slablock);
         ASSERT(slab->available < cache->objects);
-
-        *((int *)obj) = slab->nextavail;
+        
+        *((size_t *) obj) = slab->nextavail;
         slab->nextavail = (obj - slab->start) / cache->size;
         slab->available++;
-
+        
         /* Move it to correct list */
         if (slab->available == cache->objects) {
@@ -268 +278 @@
                 list_remove(&slab->link);
                 spinlock_unlock(&cache->slablock);
-
+                
                 return freed + slab_space_free(cache, slab);
-
         } else if (slab->available == 1) {
                 /* It was in full, move to partial */
@@ -276 +285 @@
                 list_prepend(&slab->link, &cache->partial_slabs);
         }
+        
         spinlock_unlock(&cache->slablock);
         return freed;
 }
 
-/**
- * Take new object from slab or create new if needed
+/** Take new object from slab or create new if needed
  *
  * @return Object address or null
- */
-static void *slab_obj_create(slab_cache_t *cache, int flags)
-{
+ *
+ */
+NO_TRACE static void *slab_obj_create(slab_cache_t *cache, unsigned int flags)
+{
+        spinlock_lock(&cache->slablock);
+        
         slab_t *slab;
-        void *obj;
-
-        spinlock_lock(&cache->slablock);
-
+        
         if (list_empty(&cache->partial_slabs)) {
-                /* Allow recursion and reclaiming
+                /*
+                 * Allow recursion and reclaiming
                  * - this should work, as the slab control structures
                  *   are small and do not need to allocate with anything
                  *   other than frame_alloc when they are allocating,
                  *   that's why we should get recursion at most 1-level deep
+                 *
                  */
                 spinlock_unlock(&cache->slablock);
@@ -303 +314 @@
                 if (!slab)
                         return NULL;
+                
                 spinlock_lock(&cache->slablock);
         } else {
@@ -309 +321 @@
                 list_remove(&slab->link);
         }
-        obj = slab->start + slab->nextavail * cache->size;
-        slab->nextavail = *((int *)obj);
+        
+        void *obj = slab->start + slab->nextavail * cache->size;
+        slab->nextavail = *((size_t *) obj);
         slab->available--;
-
+        
         if (!slab->available)
                 list_prepend(&slab->link, &cache->full_slabs);
         else
                 list_prepend(&slab->link, &cache->partial_slabs);
-
+        
         spinlock_unlock(&cache->slablock);
-
-        if (cache->constructor && cache->constructor(obj, flags)) {
+        
+        if ((cache->constructor) && (cache->constructor(obj, flags))) {
                 /* Bad, bad, construction failed */
                 slab_obj_destroy(cache, obj, slab);
                 return NULL;
         }
+        
         return obj;
 }
 
-/**************************************/
+/****************************/
 /* CPU-Cache slab functions */
-
-/**
- * Finds a full magazine in cache, takes it from list
- * and returns it 
- *
- * @param first If true, return first, else last mag
- */
-static slab_magazine_t *get_mag_from_cache(slab_cache_t *cache, int first)
+/****************************/
+
+/** Find a full magazine in cache, take it from list and return it
+ *
+ * @param first If true, return first, else last mag.
+ *
+ */
+NO_TRACE static slab_magazine_t *get_mag_from_cache(slab_cache_t *cache,
+    bool first)
 {
         slab_magazine_t *mag = NULL;
         link_t *cur;
-
+        
         spinlock_lock(&cache->maglock);
         if (!list_empty(&cache->magazines)) {
@@ -348 +363 @@
                 else
                         cur = cache->magazines.prev;
+                
                 mag = list_get_instance(cur, slab_magazine_t, link);
                 list_remove(&mag->link);
                 atomic_dec(&cache->magazine_counter);
         }
+        
         spinlock_unlock(&cache->maglock);
         return mag;
 }
 
-/** Prepend magazine to magazine list in cache */
-static void put_mag_to_cache(slab_cache_t *cache, slab_magazine_t *mag)
+/** Prepend magazine to magazine list in cache
+ *
+ */
+NO_TRACE static void put_mag_to_cache(slab_cache_t *cache,
+    slab_magazine_t *mag)
 {
         spinlock_lock(&cache->maglock);
-
+        
         list_prepend(&mag->link, &cache->magazines);
         atomic_inc(&cache->magazine_counter);
@@ -367 +387 @@
 }
 
-/**
- * Free all objects in magazine and free memory associated with magazine
+/** Free all objects in magazine and free memory associated with magazine
  *
  * @return Number of freed pages
- */
-static size_t magazine_destroy(slab_cache_t *cache, slab_magazine_t *mag)
-{
-        unsigned int i;
+ *
+ */
+NO_TRACE static size_t magazine_destroy(slab_cache_t *cache,
+    slab_magazine_t *mag)
+{
+        size_t i;
         size_t frames = 0;
-
+        
         for (i = 0; i < mag->busy; i++) {
                 frames += slab_obj_destroy(cache, mag->objs[i], NULL);
@@ -383 +404 @@
         
         slab_free(&mag_cache, mag);
-
+        
         return frames;
 }
 
-/**
- * Find full magazine, set it as current and return it
- *
- * Assume cpu_magazine lock is held
- */
-static slab_magazine_t *get_full_current_mag(slab_cache_t *cache)
-{
-        slab_magazine_t *cmag, *lastmag, *newmag;
-
-        cmag = cache->mag_cache[CPU->id].current;
-        lastmag = cache->mag_cache[CPU->id].last;
+/** Find full magazine, set it as current and return it
+ *
+ */
+NO_TRACE static slab_magazine_t *get_full_current_mag(slab_cache_t *cache)
+{
+        slab_magazine_t *cmag = cache->mag_cache[CPU->id].current;
+        slab_magazine_t *lastmag = cache->mag_cache[CPU->id].last;
+        
+        ASSERT(spinlock_locked(&cache->mag_cache[CPU->id].lock));
+        
         if (cmag) { /* First try local CPU magazines */
                 if (cmag->busy)
                         return cmag;
-
-                if (lastmag && lastmag->busy) {
+                
+                if ((lastmag) && (lastmag->busy)) {
                         cache->mag_cache[CPU->id].current = lastmag;
                         cache->mag_cache[CPU->id].last = cmag;
@@ -408 +428 @@
                 }
         }
+        
         /* Local magazines are empty, import one from magazine list */
-        newmag = get_mag_from_cache(cache, 1);
+        slab_magazine_t *newmag = get_mag_from_cache(cache, 1);
         if (!newmag)
                 return NULL;
-
+        
         if (lastmag)
                 magazine_destroy(cache, lastmag);
-
+        
         cache->mag_cache[CPU->id].last = cmag;
         cache->mag_cache[CPU->id].current = newmag;
+        
         return newmag;
 }
 
-/**
- * Try to find object in CPU-cache magazines
+/** Try to find object in CPU-cache magazines
  *
  * @return Pointer to object or NULL if not available
- */
-static void *magazine_obj_get(slab_cache_t *cache)
-{
-        slab_magazine_t *mag;
-        void *obj;
-
+ *
+ */
+NO_TRACE static void *magazine_obj_get(slab_cache_t *cache)
+{
         if (!CPU)
                 return NULL;
-
+        
         spinlock_lock(&cache->mag_cache[CPU->id].lock);
-
-        mag = get_full_current_mag(cache);
+        
+        slab_magazine_t *mag = get_full_current_mag(cache);
         if (!mag) {
                 spinlock_unlock(&cache->mag_cache[CPU->id].lock);
                 return NULL;
         }
-        obj = mag->objs[--mag->busy];
+        
+        void *obj = mag->objs[--mag->busy];
         spinlock_unlock(&cache->mag_cache[CPU->id].lock);
+        
         atomic_dec(&cache->cached_objs);
         
@@ -448 +469 @@
 }
 
-/**
- * Assure that the current magazine is empty, return pointer to it, or NULL if 
- * no empty magazine is available and cannot be allocated
- *
- * Assume mag_cache[CPU->id].lock is held
- *
- * We have 2 magazines bound to processor. 
- * First try the current. 
- *  If full, try the last.
- *   If full, put to magazines list.
- *   allocate new, exchange last & current
- *
- */
-static slab_magazine_t *make_empty_current_mag(slab_cache_t *cache)
-{
-        slab_magazine_t *cmag,*lastmag,*newmag;
-
-        cmag = cache->mag_cache[CPU->id].current;
-        lastmag = cache->mag_cache[CPU->id].last;
-
+/** Assure that the current magazine is empty, return pointer to it,
+ * or NULL if no empty magazine is available and cannot be allocated
+ *
+ * We have 2 magazines bound to processor.
+ * First try the current.
+ * If full, try the last.
+ * If full, put to magazines list.
+ *
+ */
+NO_TRACE static slab_magazine_t *make_empty_current_mag(slab_cache_t *cache)
+{
+        slab_magazine_t *cmag = cache->mag_cache[CPU->id].current;
+        slab_magazine_t *lastmag = cache->mag_cache[CPU->id].last;
+        
+        ASSERT(spinlock_locked(&cache->mag_cache[CPU->id].lock));
+        
         if (cmag) {
                 if (cmag->busy < cmag->size)
                         return cmag;
-                if (lastmag && lastmag->busy < lastmag->size) {
+                
+                if ((lastmag) && (lastmag->busy < lastmag->size)) {
                         cache->mag_cache[CPU->id].last = cmag;
                         cache->mag_cache[CPU->id].current = lastmag;
@@ -477 +495 @@
                 }
         }
+        
         /* current | last are full | nonexistent, allocate new */
-        /* We do not want to sleep just because of caching */
-        /* Especially we do not want reclaiming to start, as 
-         * this would deadlock */
-        newmag = slab_alloc(&mag_cache, FRAME_ATOMIC | FRAME_NO_RECLAIM);
+        
+        /*
+         * We do not want to sleep just because of caching,
+         * especially we do not want reclaiming to start, as
+         * this would deadlock.
+         *
+         */
+        slab_magazine_t *newmag = slab_alloc(&mag_cache,
+            FRAME_ATOMIC | FRAME_NO_RECLAIM);
         if (!newmag)
                 return NULL;
+        
         newmag->size = SLAB_MAG_SIZE;
         newmag->busy = 0;
-
+        
         /* Flush last to magazine list */
         if (lastmag)
                 put_mag_to_cache(cache, lastmag);
-
+        
         /* Move current as last, save new as current */
-        cache->mag_cache[CPU->id].last = cmag;  
-        cache->mag_cache[CPU->id].current = newmag;     
-
+        cache->mag_cache[CPU->id].last = cmag;
+        cache->mag_cache[CPU->id].current = newmag;
+        
         return newmag;
 }
 
-/**
- * Put object into CPU-cache magazine
- *
- * @return 0 - success, -1 - could not get memory
- */
-static int magazine_obj_put(slab_cache_t *cache, void *obj)
-{
-        slab_magazine_t *mag;
-
+/** Put object into CPU-cache magazine
+ *
+ * @return 0 on success, -1 on no memory
+ *
+ */
+NO_TRACE static int magazine_obj_put(slab_cache_t *cache, void *obj)
+{
         if (!CPU)
                 return -1;
-
+        
         spinlock_lock(&cache->mag_cache[CPU->id].lock);
-
-        mag = make_empty_current_mag(cache);
+        
+        slab_magazine_t *mag = make_empty_current_mag(cache);
         if (!mag) {
                 spinlock_unlock(&cache->mag_cache[CPU->id].lock);
@@ -519 +542 @@
         
         mag->objs[mag->busy++] = obj;
-
+        
         spinlock_unlock(&cache->mag_cache[CPU->id].lock);
+        
         atomic_inc(&cache->cached_objs);
+        
         return 0;
 }
 
-
-/**************************************/
+/************************/
 /* Slab cache functions */
-
-/** Return number of objects that fit in certain cache size */
-static unsigned int comp_objects(slab_cache_t *cache)
+/************************/
+
+/** Return number of objects that fit in certain cache size
+ *
+ */
+NO_TRACE static size_t comp_objects(slab_cache_t *cache)
 {
         if (cache->flags & SLAB_CACHE_SLINSIDE)
-                return ((PAGE_SIZE << cache->order) - sizeof(slab_t)) /
-                    cache->size;
-        else 
+                return ((PAGE_SIZE << cache->order)
+                    - sizeof(slab_t)) / cache->size;
+        else
                 return (PAGE_SIZE << cache->order) / cache->size;
 }
 
-/** Return wasted space in slab */
-static unsigned int badness(slab_cache_t *cache)
-{
-        unsigned int objects;
-        unsigned int ssize;
-
-        objects = comp_objects(cache);
-        ssize = PAGE_SIZE << cache->order;
+/** Return wasted space in slab
+ *
+ */
+NO_TRACE static size_t badness(slab_cache_t *cache)
+{
+        size_t objects = comp_objects(cache);
+        size_t ssize = PAGE_SIZE << cache->order;
+        
         if (cache->flags & SLAB_CACHE_SLINSIDE)
                 ssize -= sizeof(slab_t);
+        
         return ssize - objects * cache->size;
 }
 
-/**
- * Initialize mag_cache structure in slab cache
- */
-static void make_magcache(slab_cache_t *cache)
-{
-        unsigned int i;
-        
+/** Initialize mag_cache structure in slab cache
+ *
+ */
+NO_TRACE static bool make_magcache(slab_cache_t *cache)
+{
         ASSERT(_slab_initialized >= 2);
-
+        
         cache->mag_cache = malloc(sizeof(slab_mag_cache_t) * config.cpu_count,
-            0);
+            FRAME_ATOMIC);
+        if (!cache->mag_cache)
+                return false;
+        
+        size_t i;
         for (i = 0; i < config.cpu_count; i++) {
                 memsetb(&cache->mag_cache[i], sizeof(cache->mag_cache[i]), 0);
                 spinlock_initialize(&cache->mag_cache[i].lock,
-                    "slab_maglock_cpu");
-        }
-}
-
-/** Initialize allocated memory as a slab cache */
-static void
-_slab_cache_create(slab_cache_t *cache, char *name, size_t size, size_t align,
-    int (*constructor)(void *obj, int kmflag), int (*destructor)(void *obj),
-    int flags)
-{
-        int pages;
-        ipl_t ipl;
-
+                    "slab.cache.mag_cache[].lock");
+        }
+        
+        return true;
+}
+
+/** Initialize allocated memory as a slab cache
+ *
+ */
+NO_TRACE static void _slab_cache_create(slab_cache_t *cache, const char *name,
+    size_t size, size_t align, int (*constructor)(void *obj,
+    unsigned int kmflag), size_t (*destructor)(void *obj), unsigned int flags)
+{
         memsetb(cache, sizeof(*cache), 0);
         cache->name = name;
-
+        
         if (align < sizeof(unative_t))
                 align = sizeof(unative_t);
+        
         size = ALIGN_UP(size, align);
-                
+        
         cache->size = size;
-
         cache->constructor = constructor;
         cache->destructor = destructor;
         cache->flags = flags;
-
+        
         list_initialize(&cache->full_slabs);
         list_initialize(&cache->partial_slabs);
         list_initialize(&cache->magazines);
-        spinlock_initialize(&cache->slablock, "slab_lock");
-        spinlock_initialize(&cache->maglock, "slab_maglock");
+        
+        spinlock_initialize(&cache->slablock, "slab.cache.slablock");
+        spinlock_initialize(&cache->maglock, "slab.cache.maglock");
+        
         if (!(cache->flags & SLAB_CACHE_NOMAGAZINE))
-                make_magcache(cache);
-
+                (void) make_magcache(cache);
+        
         /* Compute slab sizes, object counts in slabs etc. */
         if (cache->size < SLAB_INSIDE_SIZE)
                 cache->flags |= SLAB_CACHE_SLINSIDE;
-
+        
         /* Minimum slab order */
-        pages = SIZE2FRAMES(cache->size);
+        size_t pages = SIZE2FRAMES(cache->size);
+        
         /* We need the 2^order >= pages */
         if (pages == 1)
@@ -611 +644 @@
         else
                 cache->order = fnzb(pages - 1) + 1;
-
-        while (badness(cache) > SLAB_MAX_BADNESS(cache)) {
+        
+        while (badness(cache) > SLAB_MAX_BADNESS(cache))
                 cache->order += 1;
-        }
+        
         cache->objects = comp_objects(cache);
+        
         /* If info fits in, put it inside */
         if (badness(cache) > sizeof(slab_t))
                 cache->flags |= SLAB_CACHE_SLINSIDE;
-
+        
         /* Add cache to cache list */
-        ipl = interrupts_disable();
-        spinlock_lock(&slab_cache_lock);
-
+        irq_spinlock_lock(&slab_cache_lock, true);
         list_append(&cache->link, &slab_cache_list);
-
-        spinlock_unlock(&slab_cache_lock);
-        interrupts_restore(ipl);
-}
-
-/** Create slab cache  */
-slab_cache_t *
-slab_cache_create(char *name, size_t size, size_t align,
-    int (*constructor)(void *obj, int kmflag), int (*destructor)(void *obj),
-    int flags)
-{
-        slab_cache_t *cache;
-
-        cache = slab_alloc(&slab_cache_cache, 0);
+        irq_spinlock_unlock(&slab_cache_lock, true);
+}
+
+/** Create slab cache 
+ *
+ */
+slab_cache_t *slab_cache_create(const char *name, size_t size, size_t align,
+    int (*constructor)(void *obj, unsigned int kmflag),
+    size_t (*destructor)(void *obj), unsigned int flags)
+{
+        slab_cache_t *cache = slab_alloc(&slab_cache_cache, 0);
         _slab_cache_create(cache, name, size, align, constructor, destructor,
             flags);
+        
         return cache;
 }
 
-/** 
- * Reclaim space occupied by objects that are already free
+/** Reclaim space occupied by objects that are already free
  *
  * @param flags If contains SLAB_RECLAIM_ALL, do aggressive freeing
+ *
  * @return Number of freed pages
- */
-static size_t _slab_reclaim(slab_cache_t *cache, int flags)
-{
-        unsigned int i;
+ *
+ */
+NO_TRACE static size_t _slab_reclaim(slab_cache_t *cache, unsigned int flags)
+{
+        if (cache->flags & SLAB_CACHE_NOMAGAZINE)
+                return 0; /* Nothing to do */
+        
+        /*
+         * We count up to original magazine count to avoid
+         * endless loop
+         */
+        atomic_count_t magcount = atomic_get(&cache->magazine_counter);
+        
         slab_magazine_t *mag;
         size_t frames = 0;
-        int magcount;
-        
-        if (cache->flags & SLAB_CACHE_NOMAGAZINE)
-                return 0; /* Nothing to do */
-
-        /* We count up to original magazine count to avoid
-         * endless loop 
-         */
-        magcount = atomic_get(&cache->magazine_counter);
-        while (magcount-- && (mag=get_mag_from_cache(cache, 0))) {
-                frames += magazine_destroy(cache,mag);
-                if (!(flags & SLAB_RECLAIM_ALL) && frames)
+        
+        while ((magcount--) && (mag = get_mag_from_cache(cache, 0))) {
+                frames += magazine_destroy(cache, mag);
+                if ((!(flags & SLAB_RECLAIM_ALL)) && (frames))
                         break;
         }
@@ -673 +704 @@
                 /* Free cpu-bound magazines */
                 /* Destroy CPU magazines */
+                size_t i;
                 for (i = 0; i < config.cpu_count; i++) {
                         spinlock_lock(&cache->mag_cache[i].lock);
-
+                        
                         mag = cache->mag_cache[i].current;
                         if (mag)
@@ -685 +717 @@
                                 frames += magazine_destroy(cache, mag);
                         cache->mag_cache[i].last = NULL;
-
+                        
                         spinlock_unlock(&cache->mag_cache[i].lock);
                 }
         }
-
+        
         return frames;
 }
 
-/** Check that there are no slabs and remove cache from system  */
+/** Check that there are no slabs and remove cache from system
+ *
+ */
 void slab_cache_destroy(slab_cache_t *cache)
 {
-        ipl_t ipl;
-
-        /* First remove cache from link, so that we don't need
+        /*
+         * First remove cache from link, so that we don't need
          * to disable interrupts later
+         *
          */
-
-        ipl = interrupts_disable();
-        spinlock_lock(&slab_cache_lock);
-
+        irq_spinlock_lock(&slab_cache_lock, true);
         list_remove(&cache->link);
-
-        spinlock_unlock(&slab_cache_lock);
-        interrupts_restore(ipl);
-
-        /* Do not lock anything, we assume the software is correct and
-         * does not touch the cache when it decides to destroy it */
+        irq_spinlock_unlock(&slab_cache_lock, true);
+        
+        /*
+         * Do not lock anything, we assume the software is correct and
+         * does not touch the cache when it decides to destroy it
+         *
+         */
         
         /* Destroy all magazines */
         _slab_reclaim(cache, SLAB_RECLAIM_ALL);
-
+        
         /* All slabs must be empty */
-        if (!list_empty(&cache->full_slabs) ||
-            !list_empty(&cache->partial_slabs))
+        if ((!list_empty(&cache->full_slabs)) ||
+            (!list_empty(&cache->partial_slabs)))
                 panic("Destroying cache that is not empty.");
-
+        
         if (!(cache->flags & SLAB_CACHE_NOMAGAZINE))
                 free(cache->mag_cache);
+        
         slab_free(&slab_cache_cache, cache);
 }
 
-/** Allocate new object from cache - if no flags given, always returns memory */
-void *slab_alloc(slab_cache_t *cache, int flags)
-{
-        ipl_t ipl;
+/** Allocate new object from cache - if no flags given, always returns memory
+ *
+ */
+void *slab_alloc(slab_cache_t *cache, unsigned int flags)
+{
+        /* Disable interrupts to avoid deadlocks with interrupt handlers */
+        ipl_t ipl = interrupts_disable();
+        
         void *result = NULL;
         
-        /* Disable interrupts to avoid deadlocks with interrupt handlers */
-        ipl = interrupts_disable();
-
-        if (!(cache->flags & SLAB_CACHE_NOMAGAZINE)) {
+        if (!(cache->flags & SLAB_CACHE_NOMAGAZINE))
                 result = magazine_obj_get(cache);
-        }
+        
         if (!result)
                 result = slab_obj_create(cache, flags);
-
+        
         interrupts_restore(ipl);
-
+        
         if (result)
                 atomic_inc(&cache->allocated_objs);
-
+        
         return result;
 }
 
-/** Return object to cache, use slab if known  */
-static void _slab_free(slab_cache_t *cache, void *obj, slab_t *slab)
-{
-        ipl_t ipl;
-
-        ipl = interrupts_disable();
-
+/** Return object to cache, use slab if known
+ *
+ */
+NO_TRACE static void _slab_free(slab_cache_t *cache, void *obj, slab_t *slab)
+{
+        ipl_t ipl = interrupts_disable();
+        
         if ((cache->flags & SLAB_CACHE_NOMAGAZINE) ||
-            magazine_obj_put(cache, obj)) {
+            (magazine_obj_put(cache, obj)))
                 slab_obj_destroy(cache, obj, slab);
-
-        }
+        
         interrupts_restore(ipl);
         atomic_dec(&cache->allocated_objs);
 }
 
-/** Return slab object to cache */
+/** Return slab object to cache
+ *
+ */
 void slab_free(slab_cache_t *cache, void *obj)
 {
@@ -771 +806 @@
 }
 
-/* Go through all caches and reclaim what is possible */
-size_t slab_reclaim(int flags)
-{
-        slab_cache_t *cache;
+/** Go through all caches and reclaim what is possible
+ *
+ * Interrupts must be disabled before calling this function,
+ * otherwise  memory allocation from interrupts can deadlock.
+ *
+ */
+size_t slab_reclaim(unsigned int flags)
+{
+        irq_spinlock_lock(&slab_cache_lock, false);
+        
+        size_t frames = 0;
         link_t *cur;
-        size_t frames = 0;
-
-        spinlock_lock(&slab_cache_lock);
-
-        /* TODO: Add assert, that interrupts are disabled, otherwise
-         * memory allocation from interrupts can deadlock.
-         */
-
         for (cur = slab_cache_list.next; cur != &slab_cache_list;
             cur = cur->next) {
-                cache = list_get_instance(cur, slab_cache_t, link);
+                slab_cache_t *cache = list_get_instance(cur, slab_cache_t, link);
                 frames += _slab_reclaim(cache, flags);
         }
-
-        spinlock_unlock(&slab_cache_lock);
-
+        
+        irq_spinlock_unlock(&slab_cache_lock, false);
+        
         return frames;
 }
 
-
-/* Print list of slabs */
+/* Print list of slabs
+ *
+ */
 void slab_print_list(void)
 {
-        int skip = 0;
-
-        printf("slab name        size     pages  obj/pg slabs  cached allocated"
-            " ctl\n");
-        printf("---------------- -------- ------ ------ ------ ------ ---------"
-            " ---\n");
-
+        printf("[slab name       ] [size  ] [pages ] [obj/pg] [slabs ]"
+            " [cached] [alloc ] [ctl]\n");
+        
+        size_t skip = 0;
         while (true) {
-                slab_cache_t *cache;
-                link_t *cur;
-                ipl_t ipl;
-                int i;
-
                 /*
                  * We must not hold the slab_cache_lock spinlock when printing
@@ -834 +861 @@
                  * statistics.
                  */
-
-                ipl = interrupts_disable();
-                spinlock_lock(&slab_cache_lock);
-
+                
+                irq_spinlock_lock(&slab_cache_lock, true);
+                
+                link_t *cur;
+                size_t i;
                 for (i = 0, cur = slab_cache_list.next;
-                    i < skip && cur != &slab_cache_list;
-                    i++, cur = cur->next)
-                        ;
-
+                    (i < skip) && (cur != &slab_cache_list);
+                    i++, cur = cur->next);
+                
                 if (cur == &slab_cache_list) {
-                        spinlock_unlock(&slab_cache_lock);
-                        interrupts_restore(ipl);
+                        irq_spinlock_unlock(&slab_cache_lock, true);
                         break;
                 }
-
+                
                 skip++;
-
-                cache = list_get_instance(cur, slab_cache_t, link);
-
-                char *name = cache->name;
+                
+                slab_cache_t *cache = list_get_instance(cur, slab_cache_t, link);
+                
+                const char *name = cache->name;
                 uint8_t order = cache->order;
                 size_t size = cache->size;
-                unsigned int objects = cache->objects;
+                size_t objects = cache->objects;
                 long allocated_slabs = atomic_get(&cache->allocated_slabs);
                 long cached_objs = atomic_get(&cache->cached_objs);
                 long allocated_objs = atomic_get(&cache->allocated_objs);
-                int flags = cache->flags;
-                
-                spinlock_unlock(&slab_cache_lock);
-                interrupts_restore(ipl);
-                
-                printf("%-16s %8" PRIs " %6d %6u %6ld %6ld %9ld %-3s\n",
+                unsigned int flags = cache->flags;
+                
+                irq_spinlock_unlock(&slab_cache_lock, true);
+                
+                printf("%-18s %8zu %8u %8zu %8ld %8ld %8ld %-5s\n",
                     name, size, (1 << order), objects, allocated_slabs,
                     cached_objs, allocated_objs,
@@ -874 +899 @@
 void slab_cache_init(void)
 {
-        int i, size;
-
         /* Initialize magazine cache */
         _slab_cache_create(&mag_cache, "slab_magazine",
@@ -881 +904 @@
             sizeof(uintptr_t), NULL, NULL, SLAB_CACHE_NOMAGAZINE |
             SLAB_CACHE_SLINSIDE);
+        
         /* Initialize slab_cache cache */
         _slab_cache_create(&slab_cache_cache, "slab_cache",
             sizeof(slab_cache_cache), sizeof(uintptr_t), NULL, NULL,
             SLAB_CACHE_NOMAGAZINE | SLAB_CACHE_SLINSIDE);
+        
         /* Initialize external slab cache */
         slab_extern_cache = slab_cache_create("slab_extern", sizeof(slab_t), 0,
             NULL, NULL, SLAB_CACHE_SLINSIDE | SLAB_CACHE_MAGDEFERRED);
-
+        
         /* Initialize structures for malloc */
+        size_t i;
+        size_t size;
+        
         for (i = 0, size = (1 << SLAB_MIN_MALLOC_W);
             i < (SLAB_MAX_MALLOC_W - SLAB_MIN_MALLOC_W + 1);
@@ -896 +924 @@
                     NULL, NULL, SLAB_CACHE_MAGDEFERRED);
         }
-#ifdef CONFIG_DEBUG       
+        
+#ifdef CONFIG_DEBUG
         _slab_initialized = 1;
 #endif
@@ -904 +933 @@
  *
  * Kernel calls this function, when it knows the real number of
- * processors. 
- * Allocate slab for cpucache and enable it on all existing
- * slabs that are SLAB_CACHE_MAGDEFERRED
+ * processors. Allocate slab for cpucache and enable it on all
+ * existing slabs that are SLAB_CACHE_MAGDEFERRED
+ *
  */
 void slab_enable_cpucache(void)
 {
-        link_t *cur;
-        slab_cache_t *s;
-
 #ifdef CONFIG_DEBUG
         _slab_initialized = 2;
 #endif
-
-        spinlock_lock(&slab_cache_lock);
-        
+        
+        irq_spinlock_lock(&slab_cache_lock, false);
+        
+        link_t *cur;
         for (cur = slab_cache_list.next; cur != &slab_cache_list;
-            cur = cur->next){
-                s = list_get_instance(cur, slab_cache_t, link);
-                if ((s->flags & SLAB_CACHE_MAGDEFERRED) !=
+            cur = cur->next) {
+                slab_cache_t *slab = list_get_instance(cur, slab_cache_t, link);
+                if ((slab->flags & SLAB_CACHE_MAGDEFERRED) !=
                     SLAB_CACHE_MAGDEFERRED)
                         continue;
-                make_magcache(s);
-                s->flags &= ~SLAB_CACHE_MAGDEFERRED;
-        }
-
-        spinlock_unlock(&slab_cache_lock);
-}
-
-/**************************************/
-/* kalloc/kfree functions             */
-void *malloc(unsigned int size, int flags)
+                
+                (void) make_magcache(slab);
+                slab->flags &= ~SLAB_CACHE_MAGDEFERRED;
+        }
+        
+        irq_spinlock_unlock(&slab_cache_lock, false);
+}
+
+void *malloc(size_t size, unsigned int flags)
 {
         ASSERT(_slab_initialized);
@@ -941 +967 @@
         if (size < (1 << SLAB_MIN_MALLOC_W))
                 size = (1 << SLAB_MIN_MALLOC_W);
-
-        int idx = fnzb(size - 1) - SLAB_MIN_MALLOC_W + 1;
-
+        
+        uint8_t idx = fnzb(size - 1) - SLAB_MIN_MALLOC_W + 1;
+        
         return slab_alloc(malloc_caches[idx], flags);
 }
 
-void *realloc(void *ptr, unsigned int size, int flags)
+void *realloc(void *ptr, size_t size, unsigned int flags)
 {
         ASSERT(_slab_initialized);
@@ -957 +983 @@
                 if (size < (1 << SLAB_MIN_MALLOC_W))
                         size = (1 << SLAB_MIN_MALLOC_W);
-                int idx = fnzb(size - 1) - SLAB_MIN_MALLOC_W + 1;
+                uint8_t idx = fnzb(size - 1) - SLAB_MIN_MALLOC_W + 1;
                 
                 new_ptr = slab_alloc(malloc_caches[idx], flags);
@@ -978 +1004 @@
         if (!ptr)
                 return;
-
+        
         slab_t *slab = obj2slab(ptr);
         _slab_free(slab->cache, ptr, slab);

kernel/generic/src/mm/tlb.c

@@ -33 +33 @@
 /**
  * @file
- * @brief       Generic TLB shootdown algorithm.
+ * @brief Generic TLB shootdown algorithm.
  *
  * The algorithm implemented here is based on the CMU TLB shootdown
@@ -53 +53 @@
 #include <cpu.h>
 
-/**
- * This lock is used for synchronisation between sender and
- * recipients of TLB shootdown message. It must be acquired
- * before CPU structure lock.
- */
-SPINLOCK_INITIALIZE(tlblock);
-
 void tlb_init(void)
 {
@@ -67 +60 @@
 #ifdef CONFIG_SMP
 
+/**
+ * This lock is used for synchronisation between sender and
+ * recipients of TLB shootdown message. It must be acquired
+ * before CPU structure lock.
+ *
+ */
+IRQ_SPINLOCK_STATIC_INITIALIZE(tlblock);
+
 /** Send TLB shootdown message.
  *
@@ -72 +73 @@
  * to all other processors.
  *
- * This function must be called with interrupts disabled.
+ * @param type  Type describing scope of shootdown.
+ * @param asid  Address space, if required by type.
+ * @param page  Virtual page address, if required by type.
+ * @param count Number of pages, if required by type.
  *
- * @param type Type describing scope of shootdown.
- * @param asid Address space, if required by type.
- * @param page Virtual page address, if required by type.
- * @param count Number of pages, if required by type.
+ * @return The interrupt priority level as it existed prior to this call.
+ *
  */
-void tlb_shootdown_start(tlb_invalidate_type_t type, asid_t asid,
+ipl_t tlb_shootdown_start(tlb_invalidate_type_t type, asid_t asid,
     uintptr_t page, size_t count)
 {
-        unsigned int i;
-
-        CPU->tlb_active = 0;
-        spinlock_lock(&tlblock);
+        ipl_t ipl = interrupts_disable();
+        CPU->tlb_active = false;
+        irq_spinlock_lock(&tlblock, false);
         
+        size_t i;
         for (i = 0; i < config.cpu_count; i++) {
-                cpu_t *cpu;
-                
                 if (i == CPU->id)
                         continue;
-
-                cpu = &cpus[i];
-                spinlock_lock(&cpu->lock);
+                
+                cpu_t *cpu = &cpus[i];
+                
+                irq_spinlock_lock(&cpu->lock, false);
                 if (cpu->tlb_messages_count == TLB_MESSAGE_QUEUE_LEN) {
                         /*
@@ -115 +116 @@
                         cpu->tlb_messages[idx].count = count;
                 }
-                spinlock_unlock(&cpu->lock);
+                irq_spinlock_unlock(&cpu->lock, false);
         }
         
         tlb_shootdown_ipi_send();
-
-busy_wait:      
-        for (i = 0; i < config.cpu_count; i++)
+        
+busy_wait:
+        for (i = 0; i < config.cpu_count; i++) {
                 if (cpus[i].tlb_active)
                         goto busy_wait;
+        }
+        
+        return ipl;
 }
 
-/** Finish TLB shootdown sequence. */
-void tlb_shootdown_finalize(void)
+/** Finish TLB shootdown sequence.
+ *
+ * @param ipl Previous interrupt priority level.
+ *
+ */
+void tlb_shootdown_finalize(ipl_t ipl)
 {
-        spinlock_unlock(&tlblock);
-        CPU->tlb_active = 1;
+        irq_spinlock_unlock(&tlblock, false);
+        CPU->tlb_active = true;
+        interrupts_restore(ipl);
 }
 
@@ -138 +147 @@
 }
 
-/** Receive TLB shootdown message. */
+/** Receive TLB shootdown message.
+ *
+ */
 void tlb_shootdown_ipi_recv(void)
 {
-        tlb_invalidate_type_t type;
-        asid_t asid;
-        uintptr_t page;
-        size_t count;
-        unsigned int i;
-        
         ASSERT(CPU);
         
-        CPU->tlb_active = 0;
-        spinlock_lock(&tlblock);
-        spinlock_unlock(&tlblock);
+        CPU->tlb_active = false;
+        irq_spinlock_lock(&tlblock, false);
+        irq_spinlock_unlock(&tlblock, false);
         
-        spinlock_lock(&CPU->lock);
+        irq_spinlock_lock(&CPU->lock, false);
         ASSERT(CPU->tlb_messages_count <= TLB_MESSAGE_QUEUE_LEN);
-
+        
+        size_t i;
         for (i = 0; i < CPU->tlb_messages_count; CPU->tlb_messages_count--) {
-                type = CPU->tlb_messages[i].type;
-                asid = CPU->tlb_messages[i].asid;
-                page = CPU->tlb_messages[i].page;
-                count = CPU->tlb_messages[i].count;
-
+                tlb_invalidate_type_t type = CPU->tlb_messages[i].type;
+                asid_t asid = CPU->tlb_messages[i].asid;
+                uintptr_t page = CPU->tlb_messages[i].page;
+                size_t count = CPU->tlb_messages[i].count;
+                
                 switch (type) {
                 case TLB_INVL_ALL:
@@ -170 +176 @@
                         break;
                 case TLB_INVL_PAGES:
-                        ASSERT(count);
+                        ASSERT(count);
                         tlb_invalidate_pages(asid, page, count);
                         break;
@@ -177 +183 @@
                         break;
                 }
+                
                 if (type == TLB_INVL_ALL)
                         break;
         }
         
-        spinlock_unlock(&CPU->lock);
-        CPU->tlb_active = 1;
+        irq_spinlock_unlock(&CPU->lock, false);
+        CPU->tlb_active = true;
 }