Changeset c621f4aa in mainline for kernel/genarch/src

Timestamp:

2010-07-25T10:11:13Z (16 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

377cce8

Parents:

24a2517 (diff), a2da43c (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 with mainline.

Location:

kernel/genarch/src

Files:

• acpi/acpi.c (modified) (7 diffs)
• acpi/madt.c (modified) (5 diffs)
• drivers/dsrln/dsrlnout.c (modified) (1 diff)
• drivers/ega/ega.c (modified) (8 diffs)
• drivers/i8042/i8042.c (modified) (1 diff)
• drivers/s3c24xx_uart/s3c24xx_uart.c (added)
• drivers/via-cuda/cuda.c (modified) (1 diff)
• fb/fb.c (modified) (2 diffs)
• kbrd/kbrd.c (modified) (1 diff)
• kbrd/kbrd_pl050.c (modified) (1 diff)
• kbrd/scanc_mac.c (modified) (1 diff)
• kbrd/scanc_pc.c (modified) (1 diff)
• kbrd/scanc_pl050.c (modified) (1 diff)
• kbrd/scanc_sun.c (modified) (1 diff)
• mm/as_ht.c (modified) (9 diffs)
• mm/as_pt.c (modified) (8 diffs)
• mm/asid.c (modified) (4 diffs)
• mm/page_ht.c (modified) (14 diffs)
• mm/page_pt.c (modified) (7 diffs)
• multiboot/multiboot.c (modified) (1 diff)
• ofw/ebus.c (modified) (1 diff)
• ofw/fhc.c (modified) (1 diff)
• ofw/ofw_tree.c (modified) (3 diffs)
• ofw/pci.c (modified) (1 diff)
• srln/srln.c (modified) (1 diff)

kernel/genarch/src/acpi/acpi.c

@@ -33 +33 @@
 /**
  * @file
- * @brief       Advanced Configuration and Power Interface (ACPI) initialization.
- */
- 
+ * @brief Advanced Configuration and Power Interface (ACPI) initialization.
+ */
+
 #include <genarch/acpi/acpi.h>
 #include <genarch/acpi/madt.h>
@@ -43 +43 @@
 #include <print.h>
 
-#define RSDP_SIGNATURE          "RSD PTR "
-#define RSDP_REVISION_OFFS      15
+#define RSDP_SIGNATURE      "RSD PTR "
+#define RSDP_REVISION_OFFS  15
 
 #define CMP_SIGNATURE(left, right) \
@@ -64 +64 @@
 };
 
-static int rsdp_check(uint8_t *rsdp) {
-        struct acpi_rsdp *r = (struct acpi_rsdp *) rsdp;
+static int rsdp_check(uint8_t *_rsdp) {
+        struct acpi_rsdp *rsdp = (struct acpi_rsdp *) _rsdp;
+        uint8_t sum = 0;
+        uint32_t i;
+        
+        for (i = 0; i < 20; i++)
+                sum = (uint8_t) (sum + _rsdp[i]);
+        
+        if (sum)
+                return 0; /* bad checksum */
+        
+        if (rsdp->revision == 0)
+                return 1; /* ACPI 1.0 */
+        
+        for (; i < rsdp->length; i++)
+                sum = (uint8_t) (sum + _rsdp[i]);
+        
+        return !sum;
+}
+
+int acpi_sdt_check(uint8_t *sdt)
+{
+        struct acpi_sdt_header *hdr = (struct acpi_sdt_header *) sdt;
         uint8_t sum = 0;
         unsigned int i;
         
-        for (i = 0; i < 20; i++)
-                sum = (uint8_t) (sum + rsdp[i]);
-                
-        if (sum)        
-                return 0; /* bad checksum */
-
-        if (r->revision == 0)
-                return 1; /* ACPI 1.0 */
-                
-        for (; i < r->length; i++)
-                sum = (uint8_t) (sum + rsdp[i]);
-                
+        for (i = 0; i < hdr->length; i++)
+                sum = (uint8_t) (sum + sdt[i]);
+        
         return !sum;
-        
-}
-
-int acpi_sdt_check(uint8_t *sdt)
-{
-        struct acpi_sdt_header *h = (struct acpi_sdt_header *) sdt;
-        uint8_t sum = 0;
-        unsigned int i;
-
-        for (i = 0; i < h->length; i++)
-                sum = (uint8_t) (sum + sdt[i]);
-                
-        return !sum;
 }
 
 static void map_sdt(struct acpi_sdt_header *sdt)
 {
-        page_mapping_insert(AS_KERNEL, (uintptr_t) sdt, (uintptr_t) sdt, PAGE_NOT_CACHEABLE | PAGE_WRITE);
+        page_table_lock(AS_KERNEL, true);
+        page_mapping_insert(AS_KERNEL, (uintptr_t) sdt, (uintptr_t) sdt,
+            PAGE_NOT_CACHEABLE | PAGE_WRITE);
         map_structure((uintptr_t) sdt, sdt->length);
+        page_table_unlock(AS_KERNEL, true);
 }
 
 static void configure_via_rsdt(void)
 {
-        unsigned int i, j, cnt = (acpi_rsdt->header.length - sizeof(struct acpi_sdt_header)) / sizeof(uint32_t);
+        size_t i;
+        size_t j;
+        size_t cnt = (acpi_rsdt->header.length - sizeof(struct acpi_sdt_header))
+            / sizeof(uint32_t);
         
         for (i = 0; i < cnt; i++) {
-                for (j = 0; j < sizeof(signature_map) / sizeof(struct acpi_signature_map); j++) {
-                        struct acpi_sdt_header *h = (struct acpi_sdt_header *) (unative_t) acpi_rsdt->entry[i];
-                
-                        map_sdt(h);
-                        if (CMP_SIGNATURE(h->signature, signature_map[j].signature)) {
-                                if (!acpi_sdt_check((uint8_t *) h))
-                                        goto next;
-                                *signature_map[j].sdt_ptr = h;
-                                LOG("%p: ACPI %s\n", *signature_map[j].sdt_ptr, signature_map[j].description);
+                for (j = 0; j < sizeof(signature_map)
+                    / sizeof(struct acpi_signature_map); j++) {
+                        struct acpi_sdt_header *hdr =
+                            (struct acpi_sdt_header *) (unative_t) acpi_rsdt->entry[i];
+                        
+                        map_sdt(hdr);
+                        if (CMP_SIGNATURE(hdr->signature, signature_map[j].signature)) {
+                                if (!acpi_sdt_check((uint8_t *) hdr))
+                                        break;
+                                
+                                *signature_map[j].sdt_ptr = hdr;
+                                LOG("%p: ACPI %s", *signature_map[j].sdt_ptr,
+                                    signature_map[j].description);
                         }
                 }
-next:
-                ;
         }
 }
@@ -126 +133 @@
 static void configure_via_xsdt(void)
 {
-        unsigned int i, j, cnt = (acpi_xsdt->header.length - sizeof(struct acpi_sdt_header)) / sizeof(uint64_t);
+        size_t i;
+        size_t j;
+        size_t cnt = (acpi_xsdt->header.length - sizeof(struct acpi_sdt_header))
+            / sizeof(uint64_t);
         
         for (i = 0; i < cnt; i++) {
-                for (j = 0; j < sizeof(signature_map) / sizeof(struct acpi_signature_map); j++) {
-                        struct acpi_sdt_header *h = (struct acpi_sdt_header *) ((uintptr_t) acpi_rsdt->entry[i]);
-
-                        map_sdt(h);
-                        if (CMP_SIGNATURE(h->signature, signature_map[j].signature)) {
-                                if (!acpi_sdt_check((uint8_t *) h))
-                                        goto next;
-                                *signature_map[j].sdt_ptr = h;
-                                LOG("%p: ACPI %s\n", *signature_map[j].sdt_ptr, signature_map[j].description);
+                for (j = 0; j < sizeof(signature_map)
+                    / sizeof(struct acpi_signature_map); j++) {
+                        struct acpi_sdt_header *hdr =
+                            (struct acpi_sdt_header *) ((uintptr_t) acpi_xsdt->entry[i]);
+                        
+                        map_sdt(hdr);
+                        if (CMP_SIGNATURE(hdr->signature, signature_map[j].signature)) {
+                                if (!acpi_sdt_check((uint8_t *) hdr))
+                                        break;
+                                
+                                *signature_map[j].sdt_ptr = hdr;
+                                LOG("%p: ACPI %s", *signature_map[j].sdt_ptr,
+                                    signature_map[j].description);
                         }
                 }
-next:
-                ;
-        }
-
+        }
 }
 
@@ -149 +160 @@
 {
         uint8_t *addr[2] = { NULL, (uint8_t *) PA2KA(0xe0000) };
-        int i, j, length[2] = { 1024, 128*1024 };
+        unsigned int i;
+        unsigned int j;
+        unsigned int length[2] = { 1024, 128 * 1024 };
         uint64_t *sig = (uint64_t *) RSDP_SIGNATURE;
-
+        
         /*
          * Find Root System Description Pointer
@@ -157 +170 @@
          * 2. search 128K starting at 0xe0000
          */
-
+        
         addr[0] = (uint8_t *) PA2KA(ebda);
         for (i = (ebda ? 0 : 1); i < 2; i++) {
                 for (j = 0; j < length[i]; j += 16) {
-                        if (*((uint64_t *) &addr[i][j]) == *sig && rsdp_check(&addr[i][j])) {
+                        if ((*((uint64_t *) &addr[i][j]) == *sig)
+                            && (rsdp_check(&addr[i][j]))) {
                                 acpi_rsdp = (struct acpi_rsdp *) &addr[i][j];
                                 goto rsdp_found;
@@ -167 +181 @@
                 }
         }
-
+        
         return;
-
+        
 rsdp_found:
-        LOG("%p: ACPI Root System Description Pointer\n", acpi_rsdp);
-
-        acpi_rsdt = (struct acpi_rsdt *) (unative_t) acpi_rsdp->rsdt_address;
+        LOG("%p: ACPI Root System Description Pointer", acpi_rsdp);
+        
+        acpi_rsdt = (struct acpi_rsdt *) ((uintptr_t) acpi_rsdp->rsdt_address);
         if (acpi_rsdp->revision)
                 acpi_xsdt = (struct acpi_xsdt *) ((uintptr_t) acpi_rsdp->xsdt_address);
-
+        
         if (acpi_rsdt)
                 map_sdt((struct acpi_sdt_header *) acpi_rsdt);
+        
         if (acpi_xsdt)
                 map_sdt((struct acpi_sdt_header *) acpi_xsdt);
-
-        if (acpi_rsdt && !acpi_sdt_check((uint8_t *) acpi_rsdt)) {
+        
+        if ((acpi_rsdt) && (!acpi_sdt_check((uint8_t *) acpi_rsdt))) {
                 printf("RSDT: bad checksum\n");
                 return;
         }
-        if (acpi_xsdt && !acpi_sdt_check((uint8_t *) acpi_xsdt)) {
+        
+        if ((acpi_xsdt) && (!acpi_sdt_check((uint8_t *) acpi_xsdt))) {
                 printf("XSDT: bad checksum\n");
                 return;
         }
-
+        
         if (acpi_xsdt)
                 configure_via_xsdt();
         else if (acpi_rsdt)
                 configure_via_rsdt();
-
 }
 

kernel/genarch/src/acpi/madt.c

@@ -27 +27 @@
  */
 
-/** @addtogroup genarch 
+/** @addtogroup genarch
  * @{
  */
 /**
  * @file
- * @brief       Multiple APIC Description Table (MADT) parsing.
- */
-
-#include <arch/types.h>
+ * @brief Multiple APIC Description Table (MADT) parsing.
+ */
+
+#include <typedefs.h>
 #include <genarch/acpi/acpi.h>
 #include <genarch/acpi/madt.h>
@@ -52 +52 @@
 #ifdef CONFIG_SMP
 
-/** Standard ISA IRQ map; can be overriden by Interrupt Source Override entries of MADT. */
-int isa_irq_map[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
-
-static void madt_l_apic_entry(struct madt_l_apic *la, uint32_t index);
-static void madt_io_apic_entry(struct madt_io_apic *ioa, uint32_t index);
-static void madt_intr_src_ovrd_entry(struct madt_intr_src_ovrd *override, uint32_t index);
-static int madt_cmp(void * a, void * b);
+/**
+ * Standard ISA IRQ map; can be overriden by
+ * Interrupt Source Override entries of MADT.
+ */
+static int isa_irq_map[] =
+    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
 
 struct madt_l_apic *madt_l_apic_entries = NULL;
 struct madt_io_apic *madt_io_apic_entries = NULL;
 
-size_t madt_l_apic_entry_index = 0;
-size_t madt_io_apic_entry_index = 0;
-size_t madt_l_apic_entry_cnt = 0;
-size_t madt_io_apic_entry_cnt = 0;
-size_t cpu_count = 0;
-
-struct madt_apic_header * * madt_entries_index = NULL;
-unsigned int madt_entries_index_cnt = 0;
-
-char *entry[] = {
+static size_t madt_l_apic_entry_index = 0;
+static size_t madt_io_apic_entry_index = 0;
+static size_t madt_l_apic_entry_cnt = 0;
+static size_t madt_io_apic_entry_cnt = 0;
+
+static struct madt_apic_header **madt_entries_index = NULL;
+
+const char *entry[] = {
         "L_APIC",
         "IO_APIC",
@@ -84 +81 @@
 };
 
-/*
- * ACPI MADT Implementation of SMP configuration interface.
- */
-static size_t madt_cpu_count(void);
-static bool madt_cpu_enabled(size_t i);
-static bool madt_cpu_bootstrap(size_t i);
-static uint8_t madt_cpu_apic_id(size_t i);
-static int madt_irq_to_pin(unsigned int irq);
-
+static uint8_t madt_cpu_apic_id(size_t i)
+{
+        ASSERT(i < madt_l_apic_entry_cnt);
+        
+        return ((struct madt_l_apic *)
+            madt_entries_index[madt_l_apic_entry_index + i])->apic_id;
+}
+
+static bool madt_cpu_enabled(size_t i)
+{
+        ASSERT(i < madt_l_apic_entry_cnt);
+        
+        /*
+         * FIXME: The current local APIC driver limits usable
+         * CPU IDs to 8.
+         *
+         */
+        if (i > 7)
+                return false;
+        
+        return ((struct madt_l_apic *)
+            madt_entries_index[madt_l_apic_entry_index + i])->flags & 0x1;
+}
+
+static bool madt_cpu_bootstrap(size_t i)
+{
+        ASSERT(i < madt_l_apic_entry_cnt);
+        
+        return ((struct madt_l_apic *)
+            madt_entries_index[madt_l_apic_entry_index + i])->apic_id ==
+            bsp_l_apic;
+}
+
+static int madt_irq_to_pin(unsigned int irq)
+{
+        ASSERT(irq < sizeof(isa_irq_map) / sizeof(int));
+        
+        return isa_irq_map[irq];
+}
+
+/** ACPI MADT Implementation of SMP configuration interface.
+ *
+ */
 struct smp_config_operations madt_config_operations = {
-        .cpu_count = madt_cpu_count,
         .cpu_enabled = madt_cpu_enabled,
         .cpu_bootstrap = madt_cpu_bootstrap,
@@ -101 +131 @@
 };
 
-size_t madt_cpu_count(void)
-{
-        return madt_l_apic_entry_cnt;
-}
-
-bool madt_cpu_enabled(size_t i)
-{
-        ASSERT(i < madt_l_apic_entry_cnt);
-        return ((struct madt_l_apic *) madt_entries_index[madt_l_apic_entry_index + i])->flags & 0x1;
-
-}
-
-bool madt_cpu_bootstrap(size_t i)
-{
-        ASSERT(i < madt_l_apic_entry_cnt);
-        return ((struct madt_l_apic *) madt_entries_index[madt_l_apic_entry_index + i])->apic_id == l_apic_id();
-}
-
-uint8_t madt_cpu_apic_id(size_t i)
-{
-        ASSERT(i < madt_l_apic_entry_cnt);
-        return ((struct madt_l_apic *) madt_entries_index[madt_l_apic_entry_index + i])->apic_id;
-}
-
-int madt_irq_to_pin(unsigned int irq)
-{
-        ASSERT(irq < sizeof(isa_irq_map) / sizeof(int));
-        return isa_irq_map[irq];
-}
-
-int madt_cmp(void * a, void * b) 
-{
-        return 
-                (((struct madt_apic_header *) a)->type > ((struct madt_apic_header *) b)->type) ?
-                1 : 
-                ((((struct madt_apic_header *) a)->type < ((struct madt_apic_header *) b)->type) ? -1 : 0);
-}
-        
-void acpi_madt_parse(void)
-{
-        struct madt_apic_header *end = (struct madt_apic_header *) (((uint8_t *) acpi_madt) + acpi_madt->header.length);
-        struct madt_apic_header *h;
-        
-        l_apic = (uint32_t *) (unative_t) acpi_madt->l_apic_address;
-
-        /* calculate madt entries */
-        for (h = &acpi_madt->apic_header[0]; h < end; h = (struct madt_apic_header *) (((uint8_t *) h) + h->length)) {
-                madt_entries_index_cnt++;
-        }
-
-        /* create madt apic entries index array */
-        madt_entries_index = (struct madt_apic_header * *) malloc(madt_entries_index_cnt * sizeof(struct madt_apic_header * *), FRAME_ATOMIC);
-        if (!madt_entries_index)
-                panic("Memory allocation error.");
-
-        uint32_t index = 0;
-
-        for (h = &acpi_madt->apic_header[0]; h < end; h = (struct madt_apic_header *) (((uint8_t *) h) + h->length)) {
-                madt_entries_index[index++] = h;
-        }
-
-        /* Quicksort MADT index structure */
-        qsort(madt_entries_index, madt_entries_index_cnt, sizeof(uintptr_t), &madt_cmp);
-
-        /* Parse MADT entries */
-        if (madt_entries_index_cnt > 0) {       
-                for (index = 0; index < madt_entries_index_cnt - 1; index++) {
-                        h = madt_entries_index[index];
-                        switch (h->type) {
-                                case MADT_L_APIC:
-                                        madt_l_apic_entry((struct madt_l_apic *) h, index);
-                                        break;
-                                case MADT_IO_APIC:
-                                        madt_io_apic_entry((struct madt_io_apic *) h, index);
-                                        break;
-                                case MADT_INTR_SRC_OVRD:
-                                        madt_intr_src_ovrd_entry((struct madt_intr_src_ovrd *) h, index);
-                                        break;
-                                case MADT_NMI_SRC:
-                                case MADT_L_APIC_NMI:
-                                case MADT_L_APIC_ADDR_OVRD:
-                                case MADT_IO_SAPIC:
-                                case MADT_L_SAPIC:
-                                case MADT_PLATFORM_INTR_SRC:
-                                        printf("MADT: skipping %s entry (type=%" PRIu8 ")\n", entry[h->type], h->type);
-                                        break;
-        
-                                default:
-                                        if (h->type >= MADT_RESERVED_SKIP_BEGIN && h->type <= MADT_RESERVED_SKIP_END) {
-                                                printf("MADT: skipping reserved entry (type=%" PRIu8 ")\n", h->type);
-                                        }
-                                        if (h->type >= MADT_RESERVED_OEM_BEGIN) {
-                                                printf("MADT: skipping OEM entry (type=%" PRIu8 ")\n", h->type);
-                                        }
-                                        break;
-                        }
-                }
-        }
-
-        if (cpu_count)
-                config.cpu_count = cpu_count;
-}
- 
-
-void madt_l_apic_entry(struct madt_l_apic *la, uint32_t index)
-{
-        if (!madt_l_apic_entry_cnt++) {
-                madt_l_apic_entry_index = index;
-        }
-                
+static int madt_cmp(void *a, void *b, void *arg)
+{
+        uint8_t typea = (*((struct madt_apic_header **) a))->type;
+        uint8_t typeb = (*((struct madt_apic_header **) b))->type;
+        
+        if (typea > typeb)
+                return 1;
+        
+        if (typea < typeb)
+                return -1;
+        
+        return 0;
+}
+
+static void madt_l_apic_entry(struct madt_l_apic *la, size_t i)
+{
+        if (madt_l_apic_entry_cnt == 0)
+                madt_l_apic_entry_index = i;
+        
+        madt_l_apic_entry_cnt++;
+        
         if (!(la->flags & 0x1)) {
                 /* Processor is unusable, skip it. */
@@ -216 +157 @@
         }
         
-        cpu_count++;    
-        apic_id_mask |= 1<<la->apic_id;
-}
-
-void madt_io_apic_entry(struct madt_io_apic *ioa, uint32_t index)
-{
-        if (!madt_io_apic_entry_cnt++) {
-                /* remember index of the first io apic entry */
-                madt_io_apic_entry_index = index;
+        apic_id_mask |= 1 << la->apic_id;
+}
+
+static void madt_io_apic_entry(struct madt_io_apic *ioa, size_t i)
+{
+        if (madt_io_apic_entry_cnt == 0) {
+                /* Remember index of the first io apic entry */
+                madt_io_apic_entry_index = i;
                 io_apic = (uint32_t *) (unative_t) ioa->io_apic_address;
         } else {
-                /* currently not supported */
-                return;
-        }
-}
-
-void madt_intr_src_ovrd_entry(struct madt_intr_src_ovrd *override, uint32_t index)
+                /* Currently not supported */
+        }
+        
+        madt_io_apic_entry_cnt++;
+}
+
+static void madt_intr_src_ovrd_entry(struct madt_intr_src_ovrd *override,
+    size_t i)
 {
         ASSERT(override->source < sizeof(isa_irq_map) / sizeof(int));
-        printf("MADT: ignoring %s entry: bus=%" PRIu8 ", source=%" PRIu8 ", global_int=%" PRIu32 ", flags=%#" PRIx16 "\n",
-                entry[override->header.type], override->bus, override->source,
-                override->global_int, override->flags);
+        
+        printf("MADT: Ignoring %s entry: bus=%" PRIu8 ", source=%" PRIu8
+            ", global_int=%" PRIu32 ", flags=%#" PRIx16 "\n",
+            entry[override->header.type], override->bus, override->source,
+            override->global_int, override->flags);
+}
+
+void acpi_madt_parse(void)
+{
+        struct madt_apic_header *end = (struct madt_apic_header *)
+            (((uint8_t *) acpi_madt) + acpi_madt->header.length);
+        struct madt_apic_header *hdr;
+        
+        l_apic = (uint32_t *) (unative_t) acpi_madt->l_apic_address;
+        
+        /* Count MADT entries */
+        unsigned int madt_entries_index_cnt = 0;
+        for (hdr = acpi_madt->apic_header; hdr < end;
+            hdr = (struct madt_apic_header *) (((uint8_t *) hdr) + hdr->length))
+                madt_entries_index_cnt++;
+        
+        /* Create MADT APIC entries index array */
+        madt_entries_index = (struct madt_apic_header **)
+            malloc(madt_entries_index_cnt * sizeof(struct madt_apic_header *),
+            FRAME_ATOMIC);
+        if (!madt_entries_index)
+                panic("Memory allocation error.");
+        
+        size_t i = 0;
+        
+        for (hdr = acpi_madt->apic_header; hdr < end;
+            hdr = (struct madt_apic_header *) (((uint8_t *) hdr) + hdr->length)) {
+                madt_entries_index[i] = hdr;
+                i++;
+        }
+        
+        /* Sort MADT index structure */
+        if (!gsort(madt_entries_index, madt_entries_index_cnt,
+            sizeof(struct madt_apic_header *), madt_cmp, NULL))
+                panic("Sorting error.");
+        
+        /* Parse MADT entries */
+        for (i = 0; i < madt_entries_index_cnt; i++) {
+                hdr = madt_entries_index[i];
+                
+                switch (hdr->type) {
+                case MADT_L_APIC:
+                        madt_l_apic_entry((struct madt_l_apic *) hdr, i);
+                        break;
+                case MADT_IO_APIC:
+                        madt_io_apic_entry((struct madt_io_apic *) hdr, i);
+                break;
+                case MADT_INTR_SRC_OVRD:
+                        madt_intr_src_ovrd_entry((struct madt_intr_src_ovrd *) hdr, i);
+                        break;
+                case MADT_NMI_SRC:
+                case MADT_L_APIC_NMI:
+                case MADT_L_APIC_ADDR_OVRD:
+                case MADT_IO_SAPIC:
+                case MADT_L_SAPIC:
+                case MADT_PLATFORM_INTR_SRC:
+                        printf("MADT: Skipping %s entry (type=%" PRIu8 ")\n",
+                            entry[hdr->type], hdr->type);
+                        break;
+                default:
+                        if ((hdr->type >= MADT_RESERVED_SKIP_BEGIN)
+                            && (hdr->type <= MADT_RESERVED_SKIP_END))
+                                printf("MADT: Skipping reserved entry (type=%" PRIu8 ")\n",
+                                    hdr->type);
+                                
+                        if (hdr->type >= MADT_RESERVED_OEM_BEGIN)
+                                printf("MADT: Skipping OEM entry (type=%" PRIu8 ")\n",
+                                    hdr->type);
+                        
+                        break;
+                }
+        }
+        
+        if (madt_l_apic_entry_cnt > 0)
+                config.cpu_count = madt_l_apic_entry_cnt;
 }
 

kernel/genarch/src/drivers/dsrln/dsrlnout.c

@@ -41 +41 @@
 #include <console/console.h>
 #include <sysinfo/sysinfo.h>
-#include <string.h>
+#include <str.h>
 
 typedef struct {

kernel/genarch/src/drivers/ega/ega.c

@@ -42 +42 @@
 #include <arch/mm/page.h>
 #include <synch/spinlock.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <arch/asm.h>
 #include <memstr.h>
-#include <string.h>
+#include <str.h>
 #include <console/chardev.h>
 #include <console/console.h>
@@ -63 +63 @@
 
 typedef struct {
-        SPINLOCK_DECLARE(lock);
+        IRQ_SPINLOCK_DECLARE(lock);
         
         uint32_t cursor;
@@ -71 +71 @@
 } ega_instance_t;
 
-static void ega_putchar(outdev_t *dev, wchar_t ch, bool silent);
-static void ega_redraw(outdev_t *dev);
+static void ega_putchar(outdev_t *, wchar_t, bool);
+static void ega_redraw(outdev_t *);
 
 static outdev_operations_t egadev_ops = {
@@ -540 +540 @@
         ega_instance_t *instance = (ega_instance_t *) dev->data;
         
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&instance->lock);
+        irq_spinlock_lock(&instance->lock, true);
         
         switch (ch) {
@@ -564 +563 @@
         ega_move_cursor(instance, silent);
         
-        spinlock_unlock(&instance->lock);
-        interrupts_restore(ipl);
+        irq_spinlock_unlock(&instance->lock, true);
 }
 
@@ -572 +570 @@
         ega_instance_t *instance = (ega_instance_t *) dev->data;
         
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&instance->lock);
+        irq_spinlock_lock(&instance->lock, true);
         
         memcpy(instance->addr, instance->backbuf, EGA_VRAM_SIZE);
@@ -579 +576 @@
         ega_show_cursor(instance, silent);
         
-        spinlock_unlock(&instance->lock);
-        interrupts_restore(ipl);
+        irq_spinlock_unlock(&instance->lock, true);
 }
 
@@ -598 +594 @@
         egadev->data = instance;
         
-        spinlock_initialize(&instance->lock, "*ega_lock");
+        irq_spinlock_initialize(&instance->lock, "*ega.instance.lock");
         
         instance->base = base;

kernel/genarch/src/drivers/i8042/i8042.c

@@ -67 +67 @@
         i8042_instance_t *instance = irq->instance;
         i8042_t *dev = instance->i8042;
-        uint8_t status;
         
-        if (((status = pio_read_8(&dev->status)) & i8042_BUFFER_FULL_MASK)) {
+        if (pio_read_8(&dev->status) & i8042_BUFFER_FULL_MASK) {
                 uint8_t data = pio_read_8(&dev->data);
                 indev_push_character(instance->kbrdin, data);

kernel/genarch/src/drivers/via-cuda/cuda.c

@@ -99 +99 @@
                 instance->snd_bytes = 0;
 
-                spinlock_initialize(&instance->dev_lock, "cuda_dev");
+                spinlock_initialize(&instance->dev_lock, "cuda.instance.dev_lock");
 
                 /* Disable all interrupts from CUDA. */

kernel/genarch/src/fb/fb.c

@@ -49 +49 @@
 #include <bitops.h>
 #include <print.h>
-#include <string.h>
+#include <str.h>
 #include <ddi/ddi.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <byteorder.h>
 
@@ -554 +554 @@
         fbdev->data = instance;
         
-        spinlock_initialize(&instance->lock, "*fb_lock");
+        spinlock_initialize(&instance->lock, "*fb.instance.lock");
         instance->rgb_conv = rgb_conv;
         instance->pixelbytes = pixelbytes;

kernel/genarch/src/kbrd/kbrd.c

@@ -169 +169 @@
                 indev_initialize("kbrd", &instance->raw, &kbrd_raw_ops);
                 
-                spinlock_initialize(&instance->keylock, "instance_keylock");
+                spinlock_initialize(&instance->keylock, "kbrd.instance.keylock");
                 instance->keyflags = 0;
                 instance->lockflags = 0;

kernel/genarch/src/kbrd/kbrd_pl050.c

@@ -181 +181 @@
                 indev_initialize("kbrd", &instance->raw, &kbrd_raw_ops);
                 
-                spinlock_initialize(&instance->keylock, "instance_keylock");
+                spinlock_initialize(&instance->keylock, "kbrd_pl050.instance.keylock");
                 instance->keyflags = 0;
                 instance->lockflags = 0;

kernel/genarch/src/kbrd/scanc_mac.c

@@ -37 +37 @@
 #include <genarch/kbrd/scanc.h>
 #include <typedefs.h>
-#include <string.h>
+#include <str.h>
 
 /** Primary meaning of scancodes. */

kernel/genarch/src/kbrd/scanc_pc.c

@@ -37 +37 @@
 #include <genarch/kbrd/scanc.h>
 #include <typedefs.h>
-#include <string.h>
+#include <str.h>
 
 /** Primary meaning of scancodes. */

kernel/genarch/src/kbrd/scanc_pl050.c

@@ -36 +36 @@
 #include <genarch/kbrd/scanc.h>
 #include <typedefs.h>
-#include <string.h>
+#include <str.h>
 
 

kernel/genarch/src/kbrd/scanc_sun.c

@@ -37 +37 @@
 #include <genarch/kbrd/scanc.h>
 #include <typedefs.h>
-#include <string.h>
+#include <str.h>
 
 /** Primary meaning of scancodes. */

kernel/genarch/src/mm/as_ht.c

@@ -30 +30 @@
  * @{
  */
- 
+
 /**
  * @file
- * @brief       Address space functions for global page hash table.
+ * @brief Address space functions for global page hash table.
  */
 
@@ -41 +41 @@
 #include <mm/as.h>
 #include <mm/frame.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <memstr.h>
 #include <adt/hash_table.h>
 #include <synch/mutex.h>
 
-static pte_t *ht_create(int flags);
-static void ht_destroy(pte_t *page_table);
+static pte_t *ht_create(unsigned int);
+static void ht_destroy(pte_t *);
 
-static void ht_lock(as_t *as, bool lock);
-static void ht_unlock(as_t *as, bool unlock);
+static void ht_lock(as_t *, bool);
+static void ht_unlock(as_t *, bool);
+static bool ht_locked(as_t *);
 
 as_operations_t as_ht_operations = {
@@ -57 +58 @@
         .page_table_lock = ht_lock,
         .page_table_unlock = ht_unlock,
+        .page_table_locked = ht_locked,
 };
 
@@ -68 +70 @@
  *
  * @return Returns NULL.
+ *
  */
-pte_t *ht_create(int flags)
+pte_t *ht_create(unsigned int flags)
 {
         if (flags & FLAG_AS_KERNEL) {
@@ -75 +78 @@
                 mutex_initialize(&page_ht_lock, MUTEX_PASSIVE);
         }
+        
         return NULL;
 }
@@ -83 +87 @@
  *
  * @param page_table This parameter is ignored.
+ *
  */
 void ht_destroy(pte_t *page_table)
@@ -94 +99 @@
  * Interrupts must be disabled.
  *
- * @param as Address space.
+ * @param as   Address space.
  * @param lock If false, do not attempt to lock the address space.
+ *
  */
 void ht_lock(as_t *as, bool lock)
@@ -101 +107 @@
         if (lock)
                 mutex_lock(&as->lock);
+        
         mutex_lock(&page_ht_lock);
 }
@@ -109 +116 @@
  * Interrupts must be disabled.
  *
- * @param as Address space.
+ * @param as     Address space.
  * @param unlock If false, do not attempt to lock the address space.
+ *
  */
 void ht_unlock(as_t *as, bool unlock)
 {
         mutex_unlock(&page_ht_lock);
+        
         if (unlock)
                 mutex_unlock(&as->lock);
 }
 
+/** 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.
+ */
+bool ht_locked(as_t *as)
+{
+        return (mutex_locked(&page_ht_lock) && mutex_locked(&as->lock));
+}
+
 /** @}
  */

kernel/genarch/src/mm/as_pt.c

@@ -33 +33 @@
 /**
  * @file
- * @brief       Address space functions for 4-level hierarchical pagetables.
+ * @brief Address space functions for 4-level hierarchical pagetables.
  */
 
@@ -43 +43 @@
 #include <arch/mm/page.h>
 #include <arch/mm/as.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <memstr.h>
 #include <arch.h>
 
-static pte_t *ptl0_create(int flags);
-static void ptl0_destroy(pte_t *page_table);
+static pte_t *ptl0_create(unsigned int);
+static void ptl0_destroy(pte_t *);
 
-static void pt_lock(as_t *as, bool lock);
-static void pt_unlock(as_t *as, bool unlock);
+static void pt_lock(as_t *, bool);
+static void pt_unlock(as_t *, bool);
+static bool pt_locked(as_t *);
 
 as_operations_t as_pt_operations = {
@@ -57 +58 @@
         .page_table_destroy = ptl0_destroy,
         .page_table_lock = pt_lock,
-        .page_table_unlock = pt_unlock
+        .page_table_unlock = pt_unlock,
+        .page_table_locked = pt_locked,
 };
 
@@ -67 +69 @@
  *
  * @return New PTL0.
+ *
  */
-pte_t *ptl0_create(int flags)
+pte_t *ptl0_create(unsigned int flags)
 {
-        pte_t *src_ptl0, *dst_ptl0;
-        ipl_t ipl;
-        int table_size;
-
-        dst_ptl0 = (pte_t *) frame_alloc(PTL0_SIZE, FRAME_KA);
-        table_size = FRAME_SIZE << PTL0_SIZE;
-
-        if (flags & FLAG_AS_KERNEL) {
+        pte_t *dst_ptl0 = (pte_t *) frame_alloc(PTL0_SIZE, FRAME_KA);
+        size_t table_size = FRAME_SIZE << PTL0_SIZE;
+        
+        if (flags & FLAG_AS_KERNEL)
                 memsetb(dst_ptl0, table_size, 0);
-        } else {
-                uintptr_t src, dst;
-        
+        else {
                 /*
                  * Copy the kernel address space portion to new PTL0.
+                 *
                  */
-                 
-                ipl = interrupts_disable();
-                mutex_lock(&AS_KERNEL->lock);           
-                src_ptl0 = (pte_t *) PA2KA((uintptr_t) AS_KERNEL->genarch.page_table);
-
-                src = (uintptr_t) &src_ptl0[PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)];
-                dst = (uintptr_t) &dst_ptl0[PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)];
-
+                
+                mutex_lock(&AS_KERNEL->lock);
+                
+                pte_t *src_ptl0 =
+                    (pte_t *) PA2KA((uintptr_t) AS_KERNEL->genarch.page_table);
+                
+                uintptr_t src =
+                    (uintptr_t) &src_ptl0[PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)];
+                uintptr_t dst =
+                    (uintptr_t) &dst_ptl0[PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)];
+                
                 memsetb(dst_ptl0, table_size, 0);
-                memcpy((void *) dst, (void *) src, table_size - (src - (uintptr_t) src_ptl0));
+                memcpy((void *) dst, (void *) src,
+                    table_size - (src - (uintptr_t) src_ptl0));
+                
                 mutex_unlock(&AS_KERNEL->lock);
-                interrupts_restore(ipl);
         }
-
+        
         return (pte_t *) KA2PA((uintptr_t) dst_ptl0);
 }
@@ -107 +109 @@
  *
  * @param page_table Physical address of PTL0.
+ *
  */
 void ptl0_destroy(pte_t *page_table)
 {
-        frame_free((uintptr_t)page_table);
+        frame_free((uintptr_t) page_table);
 }
 
@@ -118 +121 @@
  * Interrupts must be disabled.
  *
- * @param as Address space.
+ * @param as   Address space.
  * @param lock If false, do not attempt to lock the address space.
+ *
  */
 void pt_lock(as_t *as, bool lock)
@@ -132 +136 @@
  * Interrupts must be disabled.
  *
- * @param as Address space.
+ * @param as     Address space.
  * @param unlock If false, do not attempt to unlock the address space.
+ *
  */
 void pt_unlock(as_t *as, bool unlock)
@@ -141 +146 @@
 }
 
+/** 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.
+ */
+bool pt_locked(as_t *as)
+{
+        return mutex_locked(&as->lock);
+}
+
 /** @}
  */

kernel/genarch/src/mm/asid.c

@@ -70 +70 @@
 /** Allocate free address space identifier.
  *
- * Interrupts must be disabled and inactive_as_with_asid_lock must be held
- * prior to this call
- *
  * @return New ASID.
  */
@@ -80 +77 @@
         link_t *tmp;
         as_t *as;
+
+        ASSERT(interrupts_disabled());
+        ASSERT(spinlock_locked(&asidlock));
 
         /*
@@ -126 +126 @@
                  * Get the system rid of the stolen ASID.
                  */
-                tlb_shootdown_start(TLB_INVL_ASID, asid, 0, 0);
+                ipl_t ipl = tlb_shootdown_start(TLB_INVL_ASID, asid, 0, 0);
                 tlb_invalidate_asid(asid);
-                tlb_shootdown_finalize();
+                tlb_shootdown_finalize(ipl);
         } else {
 
@@ -142 +142 @@
                  * Purge the allocated ASID from TLBs.
                  */
-                tlb_shootdown_start(TLB_INVL_ASID, asid, 0, 0);
+                ipl_t ipl = tlb_shootdown_start(TLB_INVL_ASID, asid, 0, 0);
                 tlb_invalidate_asid(asid);
-                tlb_shootdown_finalize();
+                tlb_shootdown_finalize(ipl);
         }
         

kernel/genarch/src/mm/page_ht.c

@@ -33 +33 @@
 /**
  * @file
- * @brief       Virtual Address Translation (VAT) for global page hash table.
+ * @brief Virtual Address Translation (VAT) for global page hash table.
  */
 
@@ -43 +43 @@
 #include <mm/as.h>
 #include <arch/mm/asid.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <arch/asm.h>
 #include <synch/spinlock.h>
@@ -52 +52 @@
 #include <align.h>
 
-static size_t hash(unative_t key[]);
-static bool compare(unative_t key[], size_t keys, link_t *item);
-static void remove_callback(link_t *item);
-
-static void ht_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame,
-    int flags);
-static void ht_mapping_remove(as_t *as, uintptr_t page);
-static pte_t *ht_mapping_find(as_t *as, uintptr_t page);
+static size_t hash(unative_t[]);
+static bool compare(unative_t[], size_t, link_t *);
+static void remove_callback(link_t *);
+
+static void ht_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
+static void ht_mapping_remove(as_t *, uintptr_t);
+static pte_t *ht_mapping_find(as_t *, uintptr_t);
 
 /**
@@ -65 +64 @@
  * after address space lock and after any address space area
  * locks.
+ *
  */
 mutex_t page_ht_lock;
 
-/**
- * Page hash table.
+/** Page hash table.
+ *
  * The page hash table may be accessed only when page_ht_lock is held.
+ *
  */
 hash_table_t page_ht;
@@ -93 +94 @@
  *
  * @return Index into page hash table.
+ *
  */
 size_t hash(unative_t key[])
@@ -98 +100 @@
         as_t *as = (as_t *) key[KEY_AS];
         uintptr_t page = (uintptr_t) key[KEY_PAGE];
-        size_t index;
         
         /*
@@ -104 +105 @@
          * of occurring. Least significant bits of VPN compose the
          * hash index.
-         */
-        index = ((page >> PAGE_WIDTH) & (PAGE_HT_ENTRIES - 1));
+         *
+         */
+        size_t index = ((page >> PAGE_WIDTH) & (PAGE_HT_ENTRIES - 1));
         
         /*
@@ -111 +113 @@
          * similar addresses. Least significant bits compose the
          * hash index.
+         *
          */
         index |= ((unative_t) as) & (PAGE_HT_ENTRIES - 1);
@@ -119 +122 @@
 /** Compare page hash table item with page and/or address space.
  *
- * @param key Array of one or two keys (i.e. page and/or address space).
+ * @param key  Array of one or two keys (i.e. page and/or address space).
  * @param keys Number of keys passed.
  * @param item Item to compare the keys with.
  *
  * @return true on match, false otherwise.
+ *
  */
 bool compare(unative_t key[], size_t keys, link_t *item)
 {
-        pte_t *t;
-
         ASSERT(item);
-        ASSERT((keys > 0) && (keys <= PAGE_HT_KEYS));
-
+        ASSERT(keys > 0);
+        ASSERT(keys <= PAGE_HT_KEYS);
+        
         /*
          * Convert item to PTE.
-         */
-        t = hash_table_get_instance(item, pte_t, link);
-
-        if (keys == PAGE_HT_KEYS) {
-                return (key[KEY_AS] == (uintptr_t) t->as) &&
-                    (key[KEY_PAGE] == t->page);
-        } else {
-                return (key[KEY_AS] == (uintptr_t) t->as);
-        }
+         *
+         */
+        pte_t *pte = hash_table_get_instance(item, pte_t, link);
+        
+        if (keys == PAGE_HT_KEYS)
+                return (key[KEY_AS] == (uintptr_t) pte->as) &&
+                    (key[KEY_PAGE] == pte->page);
+        
+        return (key[KEY_AS] == (uintptr_t) pte->as);
 }
 
@@ -148 +151 @@
  *
  * @param item Page hash table item being removed.
+ *
  */
 void remove_callback(link_t *item)
 {
-        pte_t *t;
-
         ASSERT(item);
-
+        
         /*
          * Convert item to PTE.
-         */
-        t = hash_table_get_instance(item, pte_t, link);
-
-        free(t);
+         *
+         */
+        pte_t *pte = hash_table_get_instance(item, pte_t, link);
+        
+        free(pte);
 }
 
@@ -166 +169 @@
  *
  * Map virtual address page to physical address frame
- * using flags. 
- *
- * The page table must be locked and interrupts must be disabled.
- *
- * @param as Address space to which page belongs.
- * @param page Virtual address of the page to be mapped.
+ * using flags.
+ *
+ * @param as    Address space to which 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 ht_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame, int flags)
-{
-        pte_t *t;
+ *
+ */
+void ht_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame,
+    unsigned int flags)
+{
         unative_t key[2] = {
                 (uintptr_t) as,
                 page = ALIGN_DOWN(page, PAGE_SIZE)
         };
+
+        ASSERT(page_table_locked(as));
         
         if (!hash_table_find(&page_ht, key)) {
-                t = (pte_t *) malloc(sizeof(pte_t), FRAME_ATOMIC);
-                ASSERT(t != NULL);
-
-                t->g = (flags & PAGE_GLOBAL) != 0;
-                t->x = (flags & PAGE_EXEC) != 0;
-                t->w = (flags & PAGE_WRITE) != 0;
-                t->k = !(flags & PAGE_USER);
-                t->c = (flags & PAGE_CACHEABLE) != 0;
-                t->p = !(flags & PAGE_NOT_PRESENT);
-                t->a = false;
-                t->d = false;
-
-                t->as = as;
-                t->page = ALIGN_DOWN(page, PAGE_SIZE);
-                t->frame = ALIGN_DOWN(frame, FRAME_SIZE);
-
-                hash_table_insert(&page_ht, key, &t->link);
+                pte_t *pte = (pte_t *) malloc(sizeof(pte_t), FRAME_ATOMIC);
+                ASSERT(pte != NULL);
+                
+                pte->g = (flags & PAGE_GLOBAL) != 0;
+                pte->x = (flags & PAGE_EXEC) != 0;
+                pte->w = (flags & PAGE_WRITE) != 0;
+                pte->k = !(flags & PAGE_USER);
+                pte->c = (flags & PAGE_CACHEABLE) != 0;
+                pte->p = !(flags & PAGE_NOT_PRESENT);
+                pte->a = false;
+                pte->d = false;
+                
+                pte->as = as;
+                pte->page = ALIGN_DOWN(page, PAGE_SIZE);
+                pte->frame = ALIGN_DOWN(frame, FRAME_SIZE);
+                
+                hash_table_insert(&page_ht, key, &pte->link);
         }
 }
@@ -210 +214 @@
  * this call visible.
  *
- * The page table must be locked and interrupts must be disabled.
- *
- * @param as Address space to wich page belongs.
+ * @param as   Address space to wich page belongs.
  * @param page Virtual address of the page to be demapped.
+ *
  */
 void ht_mapping_remove(as_t *as, uintptr_t page)
@@ -221 +224 @@
                 page = ALIGN_DOWN(page, PAGE_SIZE)
         };
+
+        ASSERT(page_table_locked(as));
         
         /*
@@ -234 +239 @@
  * 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 as   Address space to wich page belongs.
  * @param page Virtual page.
  *
  * @return NULL if there is no such mapping; requested mapping otherwise.
+ *
  */
 pte_t *ht_mapping_find(as_t *as, uintptr_t page)
 {
-        link_t *hlp;
-        pte_t *t = NULL;
         unative_t key[2] = {
                 (uintptr_t) as,
                 page = ALIGN_DOWN(page, PAGE_SIZE)
         };
-        
-        hlp = hash_table_find(&page_ht, key);
-        if (hlp)
-                t = hash_table_get_instance(hlp, pte_t, link);
-
-        return t;
+
+        ASSERT(page_table_locked(as));
+        
+        link_t *cur = hash_table_find(&page_ht, key);
+        if (cur)
+                return hash_table_get_instance(cur, pte_t, link);
+        
+        return NULL;
 }
 

kernel/genarch/src/mm/page_pt.c

@@ -33 +33 @@
 /**
  * @file
- * @brief       Virtual Address Translation for hierarchical 4-level page tables.
+ * @brief Virtual Address Translation for hierarchical 4-level page tables.
  */
 
@@ -42 +42 @@
 #include <arch/mm/page.h>
 #include <arch/mm/as.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <arch/asm.h>
 #include <memstr.h>
 
-static void pt_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame, int flags);
-static void pt_mapping_remove(as_t *as, uintptr_t page);
-static pte_t *pt_mapping_find(as_t *as, uintptr_t page);
+static void pt_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
+static void pt_mapping_remove(as_t *, uintptr_t);
+static pte_t *pt_mapping_find(as_t *, uintptr_t);
 
 page_mapping_operations_t pt_mapping_operations = {
@@ -61 +61 @@
  * using flags.
  *
- * 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 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 pt_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame, int flags)
+ *
+ */
+void pt_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame,
+    unsigned int flags)
 {
-        pte_t *ptl0, *ptl1, *ptl2, *ptl3;
-        pte_t *newpt;
-
-        ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);
-
+        pte_t *ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);
+
+        ASSERT(page_table_locked(as));
+        
         if (GET_PTL1_FLAGS(ptl0, PTL0_INDEX(page)) & PAGE_NOT_PRESENT) {
-                newpt = (pte_t *)frame_alloc(PTL1_SIZE, FRAME_KA);
+                pte_t *newpt = (pte_t *) frame_alloc(PTL1_SIZE, FRAME_KA);
                 memsetb(newpt, FRAME_SIZE << PTL1_SIZE, 0);
                 SET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page), KA2PA(newpt));
                 SET_PTL1_FLAGS(ptl0, PTL0_INDEX(page), PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE | PAGE_WRITE);
         }
-
-        ptl1 = (pte_t *) PA2KA(GET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page)));
-
+        
+        pte_t *ptl1 = (pte_t *) PA2KA(GET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page)));
+        
         if (GET_PTL2_FLAGS(ptl1, PTL1_INDEX(page)) & PAGE_NOT_PRESENT) {
-                newpt = (pte_t *)frame_alloc(PTL2_SIZE, FRAME_KA);
+                pte_t *newpt = (pte_t *) frame_alloc(PTL2_SIZE, FRAME_KA);
                 memsetb(newpt, FRAME_SIZE << PTL2_SIZE, 0);
                 SET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page), KA2PA(newpt));
                 SET_PTL2_FLAGS(ptl1, PTL1_INDEX(page), PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE | PAGE_WRITE);
         }
-
-        ptl2 = (pte_t *) PA2KA(GET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page)));
-
+        
+        pte_t *ptl2 = (pte_t *) PA2KA(GET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page)));
+        
         if (GET_PTL3_FLAGS(ptl2, PTL2_INDEX(page)) & PAGE_NOT_PRESENT) {
-                newpt = (pte_t *)frame_alloc(PTL3_SIZE, FRAME_KA);
+                pte_t *newpt = (pte_t *) frame_alloc(PTL3_SIZE, FRAME_KA);
                 memsetb(newpt, FRAME_SIZE << PTL3_SIZE, 0);
                 SET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page), KA2PA(newpt));
                 SET_PTL3_FLAGS(ptl2, PTL2_INDEX(page), PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE | PAGE_WRITE);
         }
-
-        ptl3 = (pte_t *) PA2KA(GET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page)));
-
+        
+        pte_t *ptl3 = (pte_t *) PA2KA(GET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page)));
+        
         SET_FRAME_ADDRESS(ptl3, PTL3_INDEX(page), frame);
         SET_FRAME_FLAGS(ptl3, PTL3_INDEX(page), flags);
@@ -114 +113 @@
  * Empty page tables except PTL0 are freed.
  *
- * The page table must be locked and interrupts must be disabled.
- *
- * @param as Address space to wich page belongs.
+ * @param as   Address space to wich page belongs.
  * @param page Virtual address of the page to be demapped.
+ *
  */
 void pt_mapping_remove(as_t *as, uintptr_t page)
 {
-        pte_t *ptl0, *ptl1, *ptl2, *ptl3;
-        bool empty = true;
-        int i;
+        ASSERT(page_table_locked(as));
 
         /*
          * First, remove the mapping, if it exists.
+         *
          */
-
-        ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);
-
+        
+        pte_t *ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);
         if (GET_PTL1_FLAGS(ptl0, PTL0_INDEX(page)) & PAGE_NOT_PRESENT)
                 return;
-
-        ptl1 = (pte_t *) PA2KA(GET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page)));
-
+        
+        pte_t *ptl1 = (pte_t *) PA2KA(GET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page)));
         if (GET_PTL2_FLAGS(ptl1, PTL1_INDEX(page)) & PAGE_NOT_PRESENT)
                 return;
-
-        ptl2 = (pte_t *) PA2KA(GET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page)));
-
+        
+        pte_t *ptl2 = (pte_t *) PA2KA(GET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page)));
         if (GET_PTL3_FLAGS(ptl2, PTL2_INDEX(page)) & PAGE_NOT_PRESENT)
                 return;
-
-        ptl3 = (pte_t *) PA2KA(GET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page)));
-
+        
+        pte_t *ptl3 = (pte_t *) PA2KA(GET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page)));
+        
         /* Destroy the mapping. Setting to PAGE_NOT_PRESENT is not sufficient. */
         memsetb(&ptl3[PTL3_INDEX(page)], sizeof(pte_t), 0);
-
+        
         /*
          * Second, free all empty tables along the way from PTL3 down to PTL0.
+         *
          */
         
-        /* check PTL3 */
+        /* Check PTL3 */
+        bool empty = true;
+        
+        unsigned int i;
         for (i = 0; i < PTL3_ENTRIES; i++) {
                 if (PTE_VALID(&ptl3[i])) {
@@ -160 +158 @@
                 }
         }
+        
         if (empty) {
                 /*
                  * PTL3 is empty.
                  * Release the frame and remove PTL3 pointer from preceding table.
+                 *
                  */
                 frame_free(KA2PA((uintptr_t) ptl3));
-                if (PTL2_ENTRIES)
-                        memsetb(&ptl2[PTL2_INDEX(page)], sizeof(pte_t), 0);
-                else if (PTL1_ENTRIES)
-                        memsetb(&ptl1[PTL1_INDEX(page)], sizeof(pte_t), 0);
-                else
-                        memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
+#if (PTL2_ENTRIES != 0)
+                memsetb(&ptl2[PTL2_INDEX(page)], sizeof(pte_t), 0);
+#elif (PTL1_ENTRIES != 0)
+                memsetb(&ptl1[PTL1_INDEX(page)], sizeof(pte_t), 0);
+#else
+                memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
+#endif
         } else {
                 /*
@@ -177 +178 @@
                  * Therefore, there must be a path from PTL0 to PTL3 and
                  * thus nothing to free in higher levels.
-                 */
-                return;
-        }
-        
-        /* check PTL2, empty is still true */
-        if (PTL2_ENTRIES) {
-                for (i = 0; i < PTL2_ENTRIES; i++) {
-                        if (PTE_VALID(&ptl2[i])) {
-                                empty = false;
-                                break;
-                        }
+                 *
+                 */
+                return;
+        }
+        
+        /* Check PTL2, empty is still true */
+#if (PTL2_ENTRIES != 0)
+        for (i = 0; i < PTL2_ENTRIES; i++) {
+                if (PTE_VALID(&ptl2[i])) {
+                        empty = false;
+                        break;
                 }
-                if (empty) {
-                        /*
-                         * PTL2 is empty.
-                         * Release the frame and remove PTL2 pointer from preceding table.
-                         */
-                        frame_free(KA2PA((uintptr_t) ptl2));
-                        if (PTL1_ENTRIES)
-                                memsetb(&ptl1[PTL1_INDEX(page)], sizeof(pte_t), 0);
-                        else
-                                memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
+        }
+        
+        if (empty) {
+                /*
+                 * PTL2 is empty.
+                 * Release the frame and remove PTL2 pointer from preceding table.
+                 *
+                 */
+                frame_free(KA2PA((uintptr_t) ptl2));
+#if (PTL1_ENTRIES != 0)
+                memsetb(&ptl1[PTL1_INDEX(page)], sizeof(pte_t), 0);
+#else
+                memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
+#endif
+        } else {
+                /*
+                 * PTL2 is not empty.
+                 * Therefore, there must be a path from PTL0 to PTL2 and
+                 * thus nothing to free in higher levels.
+                 *
+                 */
+                return;
+        }
+#endif /* PTL2_ENTRIES != 0 */
+        
+        /* check PTL1, empty is still true */
+#if (PTL1_ENTRIES != 0)
+        for (i = 0; i < PTL1_ENTRIES; i++) {
+                if (PTE_VALID(&ptl1[i])) {
+                        empty = false;
+                        break;
                 }
-                else {
-                        /*
-                         * PTL2 is not empty.
-                         * Therefore, there must be a path from PTL0 to PTL2 and
-                         * thus nothing to free in higher levels.
-                         */
-                        return;
-                }
-        }
-
-        /* check PTL1, empty is still true */
-        if (PTL1_ENTRIES) {
-                for (i = 0; i < PTL1_ENTRIES; i++) {
-                        if (PTE_VALID(&ptl1[i])) {
-                                empty = false;
-                                break;
-                        }
-                }
-                if (empty) {
-                        /*
-                         * PTL1 is empty.
-                         * Release the frame and remove PTL1 pointer from preceding table.
-                         */
-                        frame_free(KA2PA((uintptr_t) ptl1));
-                        memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
-                }
-        }
-
+        }
+        
+        if (empty) {
+                /*
+                 * PTL1 is empty.
+                 * Release the frame and remove PTL1 pointer from preceding table.
+                 *
+                 */
+                frame_free(KA2PA((uintptr_t) ptl1));
+                memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
+        }
+#endif /* PTL1_ENTRIES != 0 */
 }
 
@@ -234 +240 @@
  * Find mapping for virtual page.
  *
- * The page table must be locked and interrupts must be disabled.
- *
- * @param as Address space to which page belongs.
+ * @param as   Address space to which page belongs.
  * @param page Virtual page.
  *
- * @return NULL if there is no such mapping; entry from PTL3 describing the mapping otherwise.
+ * @return NULL if there is no such mapping; entry from PTL3 describing
+ *         the mapping otherwise.
+ *
  */
 pte_t *pt_mapping_find(as_t *as, uintptr_t page)
 {
-        pte_t *ptl0, *ptl1, *ptl2, *ptl3;
-
-        ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);
-
+        ASSERT(page_table_locked(as));
+
+        pte_t *ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);
         if (GET_PTL1_FLAGS(ptl0, PTL0_INDEX(page)) & PAGE_NOT_PRESENT)
                 return NULL;
-
-        ptl1 = (pte_t *) PA2KA(GET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page)));
-
+        
+        pte_t *ptl1 = (pte_t *) PA2KA(GET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page)));
         if (GET_PTL2_FLAGS(ptl1, PTL1_INDEX(page)) & PAGE_NOT_PRESENT)
                 return NULL;
-
-        ptl2 = (pte_t *) PA2KA(GET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page)));
-
+        
+        pte_t *ptl2 = (pte_t *) PA2KA(GET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page)));
         if (GET_PTL3_FLAGS(ptl2, PTL2_INDEX(page)) & PAGE_NOT_PRESENT)
                 return NULL;
-
-        ptl3 = (pte_t *) PA2KA(GET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page)));
-
+        
+        pte_t *ptl3 = (pte_t *) PA2KA(GET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page)));
+        
         return &ptl3[PTL3_INDEX(page)];
 }

kernel/genarch/src/multiboot/multiboot.c

@@ -34 +34 @@
 
 #include <genarch/multiboot/multiboot.h>
-#include <arch/types.h>
 #include <typedefs.h>
 #include <config.h>
-#include <string.h>
+#include <str.h>
 #include <macros.h>
 

kernel/genarch/src/ofw/ebus.c

@@ -40 +40 @@
 #include <genarch/ofw/pci.h>
 #include <arch/memstr.h>
-#include <string.h>
+#include <str.h>
 #include <panic.h>
 #include <debug.h>

kernel/genarch/src/ofw/fhc.c

@@ -40 +40 @@
 #include <arch/drivers/fhc.h>
 #include <arch/memstr.h>
-#include <string.h>
+#include <str.h>
 #include <panic.h>
 #include <macros.h>

kernel/genarch/src/ofw/ofw_tree.c

@@ -39 +39 @@
 #include <arch/memstr.h>
 #include <mm/slab.h>
-#include <string.h>
+#include <str.h>
 #include <panic.h>
 #include <print.h>
@@ -65 +65 @@
     const char *name)
 {
-        unsigned int i;
+        size_t i;
         
         for (i = 0; i < node->properties; i++) {
@@ -170 +170 @@
  */
 ofw_tree_node_t *ofw_tree_find_node_by_handle(ofw_tree_node_t *root,
-    uint32_t handle)
+    phandle handle)
 {
         ofw_tree_node_t *cur;

kernel/genarch/src/ofw/pci.c

@@ -41 +41 @@
 #include <arch/trap/interrupt.h>
 #include <arch/memstr.h>
-#include <string.h>
+#include <str.h>
 #include <panic.h>
 #include <macros.h>
 
 #define PCI_SPACE_MASK          0x03000000
-#define PCI_ABS_MASK            0x80000000      
+#define PCI_ABS_MASK            0x80000000
 #define PCI_REG_MASK            0x000000ff
 

kernel/genarch/src/srln/srln.c

@@ -40 +40 @@
 #include <proc/thread.h>
 #include <arch.h>
-#include <string.h>
+#include <str.h>
 
 static indev_operations_t srln_raw_ops = {