Changeset 46c20c8 in mainline for kernel/arch/amd64/src

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/arch/amd64/src

Files:

• amd64.c (modified) (5 diffs)
• asm.S (added)
• asm_utils.S (deleted)
• boot/boot.S (modified) (18 diffs)
• boot/memmap.c (modified) (1 diff)
• boot/vesa_ret.inc (modified) (1 diff)
• context.S (modified) (2 diffs)
• cpu/cpu.c (modified) (4 diffs)
• ddi/ddi.c (modified) (5 diffs)
• debug/stacktrace.c (modified) (1 diff)
• debugger.c (modified) (10 diffs)
• delay.S (modified) (1 diff)
• fpu_context.c (modified) (1 diff)
• interrupt.c (modified) (9 diffs)
• mm/page.c (modified) (3 diffs)
• pm.c (modified) (8 diffs)
• proc/scheduler.c (modified) (2 diffs)
• proc/task.c (modified) (1 diff)
• proc/thread.c (modified) (1 diff)
• smp/ap.S (modified) (3 diffs)
• syscall.c (modified) (2 diffs)
• userspace.c (modified) (2 diffs)

kernel/arch/amd64/src/amd64.c

@@ -35 +35 @@
 #include <arch.h>
 
-#include <arch/types.h>
+#include <typedefs.h>
 
 #include <config.h>
@@ -122 +122 @@
         /* Enable FPU */
         cpu_setup_fpu();
-
+        
         /* Initialize segmentation */
         pm_init();
@@ -132 +132 @@
         /* Disable alignment check */
         clean_AM_flag();
-
+        
         if (config.cpu_active == 1) {
                 interrupt_init();
@@ -228 +228 @@
             (uintptr_t) I8042_BASE);
 #endif
+        
+        /*
+         * This nasty hack should also go away ASAP.
+         */
+        trap_virtual_enable_irqs(1 << IRQ_DP8390);
+        sysinfo_set_item_val("netif.dp8390.inr", NULL, IRQ_DP8390);
 }
 
@@ -254 +260 @@
         THREAD->arch.tls = addr;
         write_msr(AMD_MSR_FS, addr);
+        
         return 0;
 }

kernel/arch/amd64/src/boot/boot.S

@@ -1 @@
-#
-# Copyright (c) 2005 Ondrej Palkovsky
-# Copyright (c) 2006 Martin Decky
-# Copyright (c) 2008 Jakub Jermar
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# - Redistributions of source code must retain the above copyright
-#   notice, this list of conditions and the following disclaimer.
-# - Redistributions in binary form must reproduce the above copyright
-#   notice, this list of conditions and the following disclaimer in the
-#   documentation and/or other materials provided with the distribution.
-# - The name of the author may not be used to endorse or promote products
-#   derived from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
+/*
+ * Copyright (c) 2005 Ondrej Palkovsky
+ * Copyright (c) 2006 Martin Decky
+ * Copyright (c) 2008 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #include <arch/boot/boot.h>
 #include <arch/boot/memmap.h>
-#include <arch/mm/page.h>       
+#include <arch/mm/page.h>
 #include <arch/mm/ptl.h>
 #include <arch/pm.h>
@@ -37 +37 @@
 #include <arch/cpuid.h>
 
-#define START_STACK     (BOOT_OFFSET - BOOT_STACK_SIZE)
+#define START_STACK  (BOOT_OFFSET - BOOT_STACK_SIZE)
 
 .section K_TEXT_START, "ax"
 
 .code32
+
+.macro pm_error msg
+        movl \msg, %esi
+        jmp pm_error_halt
+.endm
+
+.macro pm_status msg
+#ifdef CONFIG_EGA
+        pushl %esi
+        movl \msg, %esi
+        call pm_early_puts
+        popl %esi
+#endif
+.endm
+
+.macro pm2_status msg
+#ifndef CONFIG_FB
+        pm_status \msg
+#endif
+.endm
+
 .align 4
 .global multiboot_image_start
@@ -47 +68 @@
         .long MULTIBOOT_HEADER_MAGIC
         .long MULTIBOOT_HEADER_FLAGS
-        .long -(MULTIBOOT_HEADER_MAGIC + MULTIBOOT_HEADER_FLAGS)  # checksum
+        .long -(MULTIBOOT_HEADER_MAGIC + MULTIBOOT_HEADER_FLAGS)  /* checksum */
         .long multiboot_header
         .long unmapped_ktext_start
@@ -56 +77 @@
 multiboot_image_start:
         cld
-        movl $START_STACK, %esp             # initialize stack pointer
-        lgdtl bootstrap_gdtr                # initialize Global Descriptor Table register
-        
-        movw $gdtselector(KDATA_DES), %cx
+        
+        /* Initialize stack pointer */
+        movl $START_STACK, %esp
+        
+        /* Initialize Global Descriptor Table register */
+        lgdtl bootstrap_gdtr
+        
+        /* Kernel data + stack */
+        movw $GDT_SELECTOR(KDATA_DES), %cx
         movw %cx, %es
-        movw %cx, %ds                       # kernel data + stack
+        movw %cx, %ds
         movw %cx, %ss
         
-        #
-        # Simics seems to remove hidden part of GS on entering user mode
-        # when _visible_ part of GS does not point to user-mode segment.
-        #
-        
-        movw $gdtselector(UDATA_DES), %cx
+        /*
+         * Simics seems to remove hidden part of GS on entering user mode
+         * when _visible_ part of GS does not point to user-mode segment.
+         */
+        movw $GDT_SELECTOR(UDATA_DES), %cx
         movw %cx, %fs
         movw %cx, %gs
         
-        jmpl $gdtselector(KTEXT32_DES), $multiboot_meeting_point
+        jmpl $GDT_SELECTOR(KTEXT32_DES), $multiboot_meeting_point
         multiboot_meeting_point:
         
-        movl %eax, grub_eax                 # save parameters from GRUB
+        /* Save GRUB arguments */
+        movl %eax, grub_eax
         movl %ebx, grub_ebx
         
-        #
-        # Protected 32-bit. We want to reuse the code-seg descriptor,
-        # the Default operand size must not be 1 when entering long mode.
-        #
+        pm_status $status_prot
         
         movl $(INTEL_CPUID_EXTENDED), %eax
@@ -89 +112 @@
         ja extended_cpuid_supported
         
-                movl $extended_cpuid_msg, %esi
-                jmp error_halt
+                pm_error $err_extended_cpuid
         
         extended_cpuid_supported:
@@ -99 +121 @@
         jc long_mode_supported
         
-                movl $long_mode_msg, %esi
-                jmp error_halt
+                pm_error $err_long_mode
         
         long_mode_supported:
@@ -107 +128 @@
         jc noexecute_supported
         
-                movl $noexecute_msg, %esi
-                jmp error_halt
+                pm_error $err_noexecute
         
         noexecute_supported:
@@ -117 +137 @@
         jc fx_supported
         
-                movl $fx_msg, %esi
-                jmp error_halt
+                pm_error $err_fx
         
         fx_supported:
@@ -125 +144 @@
         jc sse2_supported
         
-                movl $sse2_msg, %esi
-                jmp error_halt
+                pm_error $err_sse2
         
         sse2_supported:
-
+        
 #include "vesa_prot.inc"
-
-        #
-        # Enable 64-bit page translation entries - CR4.PAE = 1.
-        # Paging is not enabled until after long mode is enabled.
-        #
+        
+        /*
+         * Protected 32-bit. We want to reuse the code-seg descriptor,
+         * the Default operand size must not be 1 when entering long mode.
+         */
+        
+        pm2_status $status_prot2
+        
+        /*
+         * Enable 64-bit page translation entries - CR4.PAE = 1.
+         * Paging is not enabled until after long mode is enabled.
+         */
         
         movl %cr4, %eax
@@ -141 +166 @@
         movl %eax, %cr4
         
-        # set up paging tables
-        
+        /* Set up paging tables */
         leal ptl_0, %eax
         movl %eax, %cr3
         
-        # enable long mode
-        
-        movl $EFER_MSR_NUM, %ecx            # EFER MSR number
-        rdmsr                               # read EFER
-        btsl $AMD_LME_FLAG, %eax            # set LME = 1
-        wrmsr                               # write EFER
-        
-        # enable paging to activate long mode (set CR0.PG = 1)
-        
+        /* Enable long mode */
+        movl $EFER_MSR_NUM, %ecx
+        rdmsr                     /* read EFER */
+        btsl $AMD_LME_FLAG, %eax  /* set LME = 1 */
+        wrmsr
+        
+        /* Enable paging to activate long mode (set CR0.PG = 1) */
         movl %cr0, %eax
         btsl $31, %eax
         movl %eax, %cr0
         
-        # at this point we are in compatibility mode
-        
-        jmpl $gdtselector(KTEXT_DES), $start64
+        /* At this point we are in compatibility mode */
+        jmpl $GDT_SELECTOR(KTEXT_DES), $start64
+
+/** Print string to EGA display (in light red) and halt.
+ *
+ * Should be executed from 32 bit protected mode with paging
+ * turned off. Stack is not required. This routine is used even
+ * if CONFIG_EGA is not enabled. Since we are going to halt the
+ * CPU anyway, it is always better to at least try to print
+ * some hints.
+ *
+ * @param %esi Pointer to the NULL-terminated string
+ *             to be print.
+ *
+ */
+pm_error_halt:
+        movl $0xb8000, %edi  /* base of EGA text mode memory */
+        xorl %eax, %eax
+        
+        /* Read bits 8 - 15 of the cursor address */
+        movw $0x3d4, %dx
+        movb $0xe, %al
+        outb %al, %dx
+        
+        movw $0x3d5, %dx
+        inb %dx, %al
+        shl $8, %ax
+        
+        /* Read bits 0 - 7 of the cursor address */
+        movw $0x3d4, %dx
+        movb $0xf, %al
+        outb %al, %dx
+        
+        movw $0x3d5, %dx
+        inb %dx, %al
+        
+        /* Sanity check for the cursor on screen */
+        cmp $2000, %ax
+        jb err_cursor_ok
+        
+                movw $1998, %ax
+        
+        err_cursor_ok:
+        
+        movw %ax, %bx
+        shl $1, %eax
+        addl %eax, %edi
+        
+        err_ploop:
+                lodsb
+                
+                cmp $0, %al
+                je err_ploop_end
+                
+                movb $0x0c, %ah  /* black background, light red foreground */
+                stosw
+                
+                /* Sanity check for the cursor on the last line */
+                inc %bx
+                cmp $2000, %bx
+                jb err_ploop
+                
+                /* Scroll the screen (24 rows) */
+                movl %esi, %edx
+                movl $0xb80a0, %esi
+                movl $0xb8000, %edi
+                movl $960, %ecx
+                rep movsl
+                
+                /* Clear the 24th row */
+                xorl %eax, %eax
+                movl $40, %ecx
+                rep stosl
+                
+                /* Go to row 24 */
+                movl %edx, %esi
+                movl $0xb8f00, %edi
+                movw $1920, %bx
+                
+                jmp err_ploop
+        err_ploop_end:
+        
+        /* Write bits 8 - 15 of the cursor address */
+        movw $0x3d4, %dx
+        movb $0xe, %al
+        outb %al, %dx
+        
+        movw $0x3d5, %dx
+        movb %bh, %al
+        outb %al, %dx
+        
+        /* Write bits 0 - 7 of the cursor address */
+        movw $0x3d4, %dx
+        movb $0xf, %al
+        outb %al, %dx
+        
+        movw $0x3d5, %dx
+        movb %bl, %al
+        outb %al, %dx
+        
+        cli
+        hlt1:
+                hlt
+                jmp hlt1
+
+/** Print string to EGA display (in light green).
+ *
+ * Should be called from 32 bit protected mode with paging
+ * turned off. A stack space of at least 24 bytes is required,
+ * but the function does not establish a stack frame.
+ *
+ * Macros such as pm_status and pm2_status take care that
+ * this function is used only when CONFIG_EGA is enabled
+ * and CONFIG_FB is disabled.
+ *
+ * @param %esi Pointer to the NULL-terminated string
+ *             to be print.
+ *
+ */
+pm_early_puts:
+        pushl %eax
+        pushl %ebx
+        pushl %ecx
+        pushl %edx
+        pushl %edi
+        
+        movl $0xb8000, %edi  /* base of EGA text mode memory */
+        xorl %eax, %eax
+        
+        /* Read bits 8 - 15 of the cursor address */
+        movw $0x3d4, %dx
+        movb $0xe, %al
+        outb %al, %dx
+        
+        movw $0x3d5, %dx
+        inb %dx, %al
+        shl $8, %ax
+        
+        /* Read bits 0 - 7 of the cursor address */
+        movw $0x3d4, %dx
+        movb $0xf, %al
+        outb %al, %dx
+        
+        movw $0x3d5, %dx
+        inb %dx, %al
+        
+        /* Sanity check for the cursor on screen */
+        cmp $2000, %ax
+        jb pm_puts_cursor_ok
+        
+                movw $1998, %ax
+        
+        pm_puts_cursor_ok:
+        
+        movw %ax, %bx
+        shl $1, %eax
+        addl %eax, %edi
+        
+        pm_puts_ploop:
+                lodsb
+                
+                cmp $0, %al
+                je pm_puts_ploop_end
+                
+                movb $0x0a, %ah  /* black background, light green foreground */
+                stosw
+                
+                /* Sanity check for the cursor on the last line */
+                inc %bx
+                cmp $2000, %bx
+                jb pm_puts_ploop
+                
+                /* Scroll the screen (24 rows) */
+                movl %esi, %edx
+                movl $0xb80a0, %esi
+                movl $0xb8000, %edi
+                movl $960, %ecx
+                rep movsl
+                
+                /* Clear the 24th row */
+                xorl %eax, %eax
+                movl $40, %ecx
+                rep stosl
+                
+                /* Go to row 24 */
+                movl %edx, %esi
+                movl $0xb8f00, %edi
+                movw $1920, %bx
+                
+                jmp pm_puts_ploop
+        pm_puts_ploop_end:
+        
+        /* Write bits 8 - 15 of the cursor address */
+        movw $0x3d4, %dx
+        movb $0xe, %al
+        outb %al, %dx
+        
+        movw $0x3d5, %dx
+        movb %bh, %al
+        outb %al, %dx
+        
+        /* Write bits 0 - 7 of the cursor address */
+        movw $0x3d4, %dx
+        movb $0xf, %al
+        outb %al, %dx
+        
+        movw $0x3d5, %dx
+        movb %bl, %al
+        outb %al, %dx
+        
+        popl %edi
+        popl %edx
+        popl %ecx
+        popl %ebx
+        popl %eax
+        
+        ret
 
 .code64
+
+.macro long_status msg
+        pushq %rdi
+        movq \msg, %rdi
+        call early_puts
+        popq %rdi
+.endm
+
 start64:
+        
+        /*
+         * Long mode.
+         */
+        
         movq $(PA2KA(START_STACK)), %rsp
         
-        # call arch_pre_main(grub_eax, grub_ebx)
+        /* Create the first stack frame */
+        pushq $0
+        movq %rsp, %rbp
+        
+        long_status $status_long
+        
+        /* Call arch_pre_main(grub_eax, grub_ebx) */
         xorq %rdi, %rdi
         movl grub_eax, %edi
         xorq %rsi, %rsi
         movl grub_ebx, %esi
-        call arch_pre_main
-        
-        # create the first stack frame
-        pushq $0
-        movq %rsp, %rbp
-
-        call main_bsp
-        
-        # not reached
-        
+        
+        movabsq $arch_pre_main, %rax
+        callq *%rax
+        
+        long_status $status_main
+        
+        /* Call main_bsp() */
+        movabsq $main_bsp, %rax
+        call *%rax
+        
+        /* Not reached */
         cli
         hlt0:
@@ -187 +443 @@
                 jmp hlt0
 
-# Print string from %esi to EGA display (in red) and halt
-error_halt:
-        movl $0xb8000, %edi       # base of EGA text mode memory
-        xorl %eax, %eax
-        
-        movw $0x3d4, %dx          # read bits 8 - 15 of the cursor address
+/** Print string to EGA display.
+ *
+ * Should be called from long mode (with paging enabled
+ * and stack established). This function is ABI compliant
+ * (without red-zone).
+ *
+ * If CONFIG_EGA is undefined or CONFIG_FB is defined
+ * then this function does nothing.
+ *
+ * @param %rdi Pointer to the NULL-terminated string
+ *             to be printed.
+ *
+ */
+early_puts:
+        
+#if ((defined(CONFIG_EGA)) && (!defined(CONFIG_FB)))
+        
+        /* Prologue, save preserved registers */
+        pushq %rbp
+        movq %rsp, %rbp
+        pushq %rbx
+        
+        movq %rdi, %rsi
+        movq $(PA2KA(0xb8000)), %rdi  /* base of EGA text mode memory */
+        xorq %rax, %rax
+        
+        /* Read bits 8 - 15 of the cursor address */
+        movw $0x3d4, %dx
         movb $0xe, %al
         outb %al, %dx
@@ -200 +478 @@
         shl $8, %ax
         
-        movw $0x3d4, %dx          # read bits 0 - 7 of the cursor address
+        /* Read bits 0 - 7 of the cursor address */
+        movw $0x3d4, %dx
         movb $0xf, %al
         outb %al, %dx
@@ -207 +486 @@
         inb %dx, %al
         
-        cmp $1920, %ax
-        jbe cursor_ok
-        
-                movw $1920, %ax       # sanity check for the cursor on the last line
-        
-        cursor_ok:
+        /* Sanity check for the cursor on screen */
+        cmp $2000, %ax
+        jb early_puts_cursor_ok
+        
+                movw $1998, %ax
+        
+        early_puts_cursor_ok:
         
         movw %ax, %bx
-        shl $1, %eax
-        addl %eax, %edi
-        
-        movw $0x0c00, %ax         # black background, light red foreground
-        
-        ploop:
+        shl $1, %rax
+        addq %rax, %rdi
+        
+        early_puts_ploop:
                 lodsb
+                
                 cmp $0, %al
-                je ploop_end
+                je early_puts_ploop_end
+                
+                movb $0x0e, %ah  /* black background, yellow foreground */
                 stosw
+                
+                /* Sanity check for the cursor on the last line */
                 inc %bx
-                jmp ploop
-        ploop_end:
-        
-        movw $0x3d4, %dx          # write bits 8 - 15 of the cursor address
+                cmp $2000, %bx
+                jb early_puts_ploop
+                
+                /* Scroll the screen (24 rows) */
+                movq %rsi, %rdx
+                movq $(PA2KA(0xb80a0)), %rsi
+                movq $(PA2KA(0xb8000)), %rdi
+                movl $480, %ecx
+                rep movsq
+                
+                /* Clear the 24th row */
+                xorl %eax, %eax
+                movl $20, %ecx
+                rep stosq
+                
+                /* Go to row 24 */
+                movq %rdx, %rsi
+                movq $(PA2KA(0xb8f00)), %rdi
+                movw $1920, %bx
+                
+                jmp early_puts_ploop
+        early_puts_ploop_end:
+        
+        /* Write bits 8 - 15 of the cursor address */
+        movw $0x3d4, %dx
         movb $0xe, %al
         outb %al, %dx
@@ -237 +541 @@
         outb %al, %dx
         
-        movw $0x3d4, %dx          # write bits 0 - 7 of the cursor address
+        /* Write bits 0 - 7 of the cursor address */
+        movw $0x3d4, %dx
         movb $0xf, %al
         outb %al, %dx
@@ -245 +550 @@
         outb %al, %dx
         
-        cli
-        hlt1:
-                hlt
-                jmp hlt1
+        /* Epilogue, restore preserved registers */
+        popq %rbx
+        leave
+        
+#endif
+        
+        ret
 
 #include "vesa_real.inc"
@@ -254 +562 @@
 .section K_INI_PTLS, "aw", @progbits
 
-#
-# Macro for generating initial page table contents.
-# @param cnt Number of entries to generat. Must be multiple of 8.
-# @param g   Number of GB that will be added to the mapping.
-#
-.macro ptl2gen cnt g 
-.if \cnt
-        ptl2gen "\cnt - 8" \g 
-        .quad ((\cnt - 8) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
-        .quad ((\cnt - 7) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
-        .quad ((\cnt - 6) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
-        .quad ((\cnt - 5) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
-        .quad ((\cnt - 4) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
-        .quad ((\cnt - 3) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
-        .quad ((\cnt - 2) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
-        .quad ((\cnt - 1) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
-.endif
+/** Generate initial page table contents.
+ *
+ * @param cnt Number of entries to generate. Must be multiple of 8.
+ * @param g   Number of GB that will be added to the mapping.
+ *
+ */
+.macro ptl2gen cnt g
+        .if \cnt
+                ptl2gen "\cnt - 8" \g
+                .quad ((\cnt - 8) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
+                .quad ((\cnt - 7) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
+                .quad ((\cnt - 6) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
+                .quad ((\cnt - 5) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
+                .quad ((\cnt - 4) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
+                .quad ((\cnt - 3) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
+                .quad ((\cnt - 2) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
+                .quad ((\cnt - 1) * 0x200000) + (\g * 1024 * 1024 * 1024) | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE)
+        .endif
 .endm
 
-# Page table for pages in the first gigabyte.
-.align 4096
-.global ptl_2_0g
-ptl_2_0g:       
+/* Page table for pages in the 1st gigabyte. */
+.align 4096
+ptl_2_0g:
         ptl2gen 512 0
 
-# Page table for pages in the second gigabyte.
-.align 4096
-.global ptl_2_1g
+/* Page table for pages in the 2nd gigabyte. */
+.align 4096
 ptl_2_1g:
         ptl2gen 512 1
 
-# Page table for pages in the third gigabyte.
-.align 4096
-.global ptl_2_2g
+/* Page table for pages in the 3rd gigabyte. */
+.align 4096
 ptl_2_2g:
         ptl2gen 512 2
 
-# Page table for pages in the fourth gigabyte.
-.align 4096
-.global ptl_2_3g
+/* Page table for pages in the 4th gigabyte. */
+.align 4096
 ptl_2_3g:
         ptl2gen 512 3
 
-.align 4096
-.global ptl_1
+/* Page table for pages in the 5th gigabyte. */
+.align 4096
+ptl_2_4g:
+        ptl2gen 512 4
+
+/* Page table for pages in the 6th gigabyte. */
+.align 4096
+ptl_2_5g:
+        ptl2gen 512 5
+
+/* Page table for pages in the 7th gigabyte. */
+.align 4096
+ptl_2_6g:
+        ptl2gen 512 6
+
+/* Page table for pages in the 8th gigabyte. */
+.align 4096
+ptl_2_7g:
+        ptl2gen 512 7
+
+.align 4096
 ptl_1:
-        # Identity mapping for [0; 4G)
+        /* Identity mapping for [0; 8G) */
         .quad ptl_2_0g + (PTL_WRITABLE | PTL_PRESENT)
-        .quad ptl_2_1g + (PTL_WRITABLE | PTL_PRESENT) 
+        .quad ptl_2_1g + (PTL_WRITABLE | PTL_PRESENT)
         .quad ptl_2_2g + (PTL_WRITABLE | PTL_PRESENT)
         .quad ptl_2_3g + (PTL_WRITABLE | PTL_PRESENT)
-        .fill 506, 8, 0
-        # Mapping of [0; 1G) at -2G
-        .quad ptl_2_0g + (PTL_WRITABLE | PTL_PRESENT)
-        .fill 1, 8, 0
+        .quad ptl_2_4g + (PTL_WRITABLE | PTL_PRESENT)
+        .quad ptl_2_5g + (PTL_WRITABLE | PTL_PRESENT)
+        .quad ptl_2_6g + (PTL_WRITABLE | PTL_PRESENT)
+        .quad ptl_2_7g + (PTL_WRITABLE | PTL_PRESENT)
+        .fill 504, 8, 0
 
 .align 4096
@@ -314 +639 @@
 ptl_0:
         .quad ptl_1 + (PTL_WRITABLE | PTL_PRESENT)
-        .fill 255,8,0
+        .fill 255, 8, 0
         .quad ptl_1 + (PTL_WRITABLE | PTL_PRESENT)
-        .fill 254,8,0
-        .quad ptl_1 + (PTL_WRITABLE | PTL_PRESENT)
+        .fill 255, 8, 0
 
 .section K_DATA_START, "aw", @progbits
 
-.global bootstrap_gdtr
 bootstrap_gdtr:
-        .word gdtselector(GDT_ITEMS)
+        .word GDT_SELECTOR(GDT_ITEMS)
         .long KA2PA(gdt)
 
@@ -332 +655 @@
         .long 0
 
-extended_cpuid_msg:
+err_extended_cpuid:
         .asciz "Error: Extended CPUID not supported -- CPU is not 64-bit. System halted."
-long_mode_msg:
+err_long_mode:
         .asciz "Error: 64-bit long mode not supported. System halted."
-noexecute_msg:
+err_noexecute:
         .asciz "Error: No-execute pages not supported. System halted."
-fx_msg:
+err_fx:
         .asciz "Error: FXSAVE/FXRESTORE instructions not supported. System halted."
-sse2_msg:
+err_sse2:
         .asciz "Error: SSE2 instructions not supported. System halted."
+
+status_prot:
+        .asciz "[prot] "
+status_vesa_copy:
+        .asciz "[vesa_copy] "
+status_grub_cmdline:
+        .asciz "[grub_cmdline] "
+status_vesa_real:
+        .asciz "[vesa_real] "
+status_prot2:
+        .asciz "[prot2] "
+status_long:
+        .asciz "[long] "
+status_main:
+        .asciz "[main] "

kernel/arch/amd64/src/boot/memmap.c

@@ -35 +35 @@
 #include <arch/boot/memmap.h>
 
-uint8_t e820counter = 0xff;
+uint8_t e820counter = 0xffU;
 e820memmap_t e820table[MEMMAP_E820_MAX_RECORDS];
 

kernel/arch/amd64/src/boot/vesa_ret.inc

@@ -1 +1 @@
 .code32
 vesa_init_protected:
-        movw $gdtselector(KDATA_DES), %cx
+        cld
+        
+        /* Initialize stack pointer */
+        movl $START_STACK, %esp
+        
+        /* Kernel data + stack */
+        movw $GDT_SELECTOR(KDATA_DES), %cx
         movw %cx, %es
-        movw %cx, %ds                       # kernel data + stack
+        movw %cx, %ds
         movw %cx, %ss
         
-        #
-        # Simics seems to remove hidden part of GS on entering user mode
-        # when _visible_ part of GS does not point to user-mode segment.
-        #
+        /*
+         * Simics seems to remove hidden part of GS on entering user mode
+         * when _visible_ part of GS does not point to user-mode segment.
+         */
         
-        movw $gdtselector(UDATA_DES), %cx
+        movw $GDT_SELECTOR(UDATA_DES), %cx
         movw %cx, %fs
         movw %cx, %gs
         
-        movl $START_STACK, %esp             # initialize stack pointer
-        
-        jmpl $gdtselector(KTEXT32_DES), $vesa_meeting_point
+        jmpl $GDT_SELECTOR(KTEXT32_DES), $vesa_meeting_point

kernel/arch/amd64/src/context.S

@@ -41 +41 @@
 context_save_arch:
         movq (%rsp), %rdx     # the caller's return %eip
-
-        # In %edi is passed 1st argument
-        CONTEXT_SAVE_ARCH_CORE %rdi %rdx 
         
-        xorq %rax,%rax          # context_save returns 1
-        incq %rax
+        # 1st argument passed in %edi
+        CONTEXT_SAVE_ARCH_CORE %rdi %rdx
+        
+        xorl %eax, %eax       # context_save returns 1
+        incl %eax
         ret
 
@@ -55 +55 @@
 # pointed by the 1st argument. Returns 0 in EAX.
 #
-context_restore_arch:   
-
+context_restore_arch:
         CONTEXT_RESTORE_ARCH_CORE %rdi %rdx
-
-        movq %rdx,(%rsp)
-
-        xorq %rax,%rax          # context_restore returns 0
+        
+        movq %rdx, (%rsp)
+        
+        xorl %eax, %eax       # context_restore returns 0
         ret

kernel/arch/amd64/src/cpu/cpu.c

@@ -39 +39 @@
 
 #include <arch.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <print.h>
 #include <fpu_context.h>
@@ -47 +47 @@
  * Contains only non-MP-Specification specific SMP code.
  */
-#define AMD_CPUID_EBX   0x68747541
-#define AMD_CPUID_ECX   0x444d4163
-#define AMD_CPUID_EDX   0x69746e65
+#define AMD_CPUID_EBX  UINT32_C(0x68747541)
+#define AMD_CPUID_ECX  UINT32_C(0x444d4163)
+#define AMD_CPUID_EDX  UINT32_C(0x69746e65)
 
-#define INTEL_CPUID_EBX 0x756e6547
-#define INTEL_CPUID_ECX 0x6c65746e
-#define INTEL_CPUID_EDX 0x49656e69
-
+#define INTEL_CPUID_EBX  UINT32_C(0x756e6547)
+#define INTEL_CPUID_ECX  UINT32_C(0x6c65746e)
+#define INTEL_CPUID_EDX  UINT32_C(0x49656e69)
 
 enum vendor {
@@ -62 +61 @@
 };
 
-static char *vendor_str[] = {
+static const char *vendor_str[] = {
         "Unknown Vendor",
         "AuthenticAMD",
@@ -127 +126 @@
 {
         cpu_info_t info;
-
+        
         CPU->arch.vendor = VendorUnknown;
         if (has_cpuid()) {
                 cpuid(INTEL_CPUID_LEVEL, &info);
-
+                
                 /*
                  * Check for AMD processor.
                  */
-                if (info.cpuid_ebx == AMD_CPUID_EBX &&
-                    info.cpuid_ecx == AMD_CPUID_ECX &&
-                    info.cpuid_edx == AMD_CPUID_EDX) {
+                if ((info.cpuid_ebx == AMD_CPUID_EBX) &&
+                    (info.cpuid_ecx == AMD_CPUID_ECX) &&
+                    (info.cpuid_edx == AMD_CPUID_EDX)) {
                         CPU->arch.vendor = VendorAMD;
                 }
-
+                
                 /*
                  * Check for Intel processor.
-                 */             
-                if (info.cpuid_ebx == INTEL_CPUID_EBX &&
-                    info.cpuid_ecx == INTEL_CPUID_ECX &&
-                    info.cpuid_edx == INTEL_CPUID_EDX) {
+                 */
+                if ((info.cpuid_ebx == INTEL_CPUID_EBX) &&
+                    (info.cpuid_ecx == INTEL_CPUID_ECX) &&
+                    (info.cpuid_edx == INTEL_CPUID_EDX)) {
                         CPU->arch.vendor = VendorIntel;
                 }
-                                
+                
                 cpuid(INTEL_CPUID_STANDARD, &info);
                 CPU->arch.family = (info.cpuid_eax >> 8) & 0xf;
                 CPU->arch.model = (info.cpuid_eax >> 4) & 0xf;
-                CPU->arch.stepping = (info.cpuid_eax >> 0) & 0xf;                                               
+                CPU->arch.stepping = (info.cpuid_eax >> 0) & 0xf;
         }
 }

kernel/arch/amd64/src/ddi/ddi.c

@@ -36 +36 @@
 #include <arch/ddi/ddi.h>
 #include <proc/task.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <adt/bitmap.h>
 #include <mm/slab.h>
@@ -49 +49 @@
  * Interrupts are disabled and task is locked.
  *
- * @param task Task.
+ * @param task   Task.
  * @param ioaddr Startign I/O space address.
- * @param size Size of the enabled I/O range.
+ * @param size   Size of the enabled I/O range.
  *
  * @return 0 on success or an error code from errno.h.
+ *
  */
 int ddi_iospace_enable_arch(task_t *task, uintptr_t ioaddr, size_t size)
 {
-        size_t bits;
-        
-        bits = ioaddr + size;
+        size_t bits = ioaddr + size;
         if (bits > IO_PORTS)
                 return ENOENT;
         
         if (task->arch.iomap.bits < bits) {
-                bitmap_t oldiomap;
-                uint8_t *newmap;
-                
                 /*
                  * The I/O permission bitmap is too small and needs to be grown.
                  */
                 
-                newmap = (uint8_t *) malloc(BITS2BYTES(bits), FRAME_ATOMIC);
+                uint8_t *newmap = (uint8_t *) malloc(BITS2BYTES(bits), FRAME_ATOMIC);
                 if (!newmap)
                         return ENOMEM;
                 
+                bitmap_t oldiomap;
                 bitmap_initialize(&oldiomap, task->arch.iomap.map,
                     task->arch.iomap.bits);
@@ -115 +112 @@
  *
  * Interrupts must be disabled prior this call.
+ *
  */
 void io_perm_bitmap_install(void)
 {
-        size_t bits;
-        ptr_16_64_t cpugdtr;
-        descriptor_t *gdt_p;
-        tss_descriptor_t *tss_desc;
-        size_t ver;
-        
         /* First, copy the I/O Permission Bitmap. */
-        spinlock_lock(&TASK->lock);
-        ver = TASK->arch.iomapver;
-        if ((bits = TASK->arch.iomap.bits)) {
+        irq_spinlock_lock(&TASK->lock, false);
+        size_t ver = TASK->arch.iomapver;
+        size_t bits = TASK->arch.iomap.bits;
+        if (bits) {
+                ASSERT(TASK->arch.iomap.map);
+                
                 bitmap_t iomap;
-        
-                ASSERT(TASK->arch.iomap.map);
                 bitmap_initialize(&iomap, CPU->arch.tss->iomap,
                     TSS_IOMAP_SIZE * 8);
-                bitmap_copy(&iomap, &TASK->arch.iomap, TASK->arch.iomap.bits);
+                bitmap_copy(&iomap, &TASK->arch.iomap, bits);
+                
+                /*
+                 * Set the trailing bits in the last byte of the map to disable
+                 * I/O access.
+                 */
+                bitmap_set_range(&iomap, bits, ALIGN_UP(bits, 8) - bits);
                 /*
                  * It is safe to set the trailing eight bits because of the
                  * extra convenience byte in TSS_IOMAP_SIZE.
                  */
-                bitmap_set_range(&iomap, ALIGN_UP(TASK->arch.iomap.bits, 8), 8);
+                bitmap_set_range(&iomap, ALIGN_UP(bits, 8), 8);
         }
-        spinlock_unlock(&TASK->lock);
+        irq_spinlock_unlock(&TASK->lock, false);
         
         /*
@@ -146 +145 @@
          * Take the extra ending byte will all bits set into account. 
          */
+        ptr_16_64_t cpugdtr;
         gdtr_store(&cpugdtr);
-        gdt_p = (descriptor_t *) cpugdtr.base;
+        
+        descriptor_t *gdt_p = (descriptor_t *) cpugdtr.base;
         gdt_tss_setlimit(&gdt_p[TSS_DES], TSS_BASIC_SIZE + BITS2BYTES(bits));
         gdtr_load(&cpugdtr);
@@ -155 +156 @@
          * type must be changed to describe inactive TSS.
          */
-        tss_desc = (tss_descriptor_t *) &gdt_p[TSS_DES];
+        tss_descriptor_t *tss_desc = (tss_descriptor_t *) &gdt_p[TSS_DES];
         tss_desc->type = AR_TSS;
-        tr_load(gdtselector(TSS_DES));
+        tr_load(GDT_SELECTOR(TSS_DES));
         
         /*

kernel/arch/amd64/src/debug/stacktrace.c

@@ -35 +35 @@
 #include <stacktrace.h>
 #include <syscall/copy.h>
-#include <arch/types.h>
 #include <typedefs.h>
 
-#define FRAME_OFFSET_FP_PREV    0
-#define FRAME_OFFSET_RA         1
+#define FRAME_OFFSET_FP_PREV  0
+#define FRAME_OFFSET_RA       1
 
-bool kernel_frame_pointer_validate(uintptr_t fp)
+bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
-        return fp != 0;
+        return ctx->fp != 0;
 }
 
-bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
-        uint64_t *stack = (void *) fp;
+        uint64_t *stack = (void *) ctx->fp;
         *prev = stack[FRAME_OFFSET_FP_PREV];
+        
         return true;
 }
 
-bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
-        uint64_t *stack = (void *) fp;
+        uint64_t *stack = (void *) ctx->fp;
         *ra = stack[FRAME_OFFSET_RA];
+        
         return true;
 }
 
-bool uspace_frame_pointer_validate(uintptr_t fp)
+bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
-        return fp != 0;
+        return ctx->fp != 0;
 }
 
-bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
         return !copy_from_uspace((void *) prev,
-            (uint64_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
+            (uint64_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
 }
 
-bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
-        return !copy_from_uspace((void *) ra, (uint64_t *) fp + FRAME_OFFSET_RA,
-            sizeof(*ra));
+        return !copy_from_uspace((void *) ra,
+            (uint64_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
 }
 

kernel/arch/amd64/src/debugger.c

@@ -46 +46 @@
 #include <symtab.h>
 
+#ifdef __64_BITS__
+        #define getip(x)  ((x)->rip)
+#endif
+
+#ifdef __32_BITS__
+        #define getip(x)  ((x)->eip)
+#endif
+
 typedef struct  {
-        uintptr_t address;      /**< Breakpoint address */
-        int flags;              /**< Flags regarding breakpoint */
-        int counter;            /**< How many times the exception occured */
+        uintptr_t address;   /**< Breakpoint address */
+        unsigned int flags;  /**< Flags regarding breakpoint */
+        size_t counter;      /**< How many times the exception occured */
 } bpinfo_t;
 
 static bpinfo_t breakpoints[BKPOINTS_MAX];
-SPINLOCK_INITIALIZE(bkpoint_lock);
+IRQ_SPINLOCK_STATIC_INITIALIZE(bkpoint_lock);
 
 #ifdef CONFIG_KCONSOLE
 
-static int cmd_print_breakpoints(cmd_arg_t *argv);
+static int cmd_print_breakpoints(cmd_arg_t *);
+static int cmd_del_breakpoint(cmd_arg_t *);
+static int cmd_add_breakpoint(cmd_arg_t *);
+
 static cmd_info_t bkpts_info = {
         .name = "bkpts",
@@ -65 +76 @@
 };
 
-static int cmd_del_breakpoint(cmd_arg_t *argv);
 static cmd_arg_t del_argv = {
         .type = ARG_TYPE_INT
 };
+
 static cmd_info_t delbkpt_info = {
         .name = "delbkpt",
-        .description = "delbkpt <number> - Delete breakpoint.",
+        .description = "Delete breakpoint.",
         .func = cmd_del_breakpoint,
         .argc = 1,
@@ -77 +88 @@
 };
 
-static int cmd_add_breakpoint(cmd_arg_t *argv);
 static cmd_arg_t add_argv = {
         .type = ARG_TYPE_INT
 };
+
 static cmd_info_t addbkpt_info = {
         .name = "addbkpt",
-        .description = "addbkpt <&symbol> - new breakpoint.",
+        .description = "Add breakpoint.",
         .func = cmd_add_breakpoint,
         .argc = 1,
@@ -92 +103 @@
         .type = ARG_TYPE_INT
 };
+
 static cmd_info_t addwatchp_info = {
         .name = "addwatchp",
-        .description = "addbwatchp <&symbol> - new write watchpoint.",
+        .description = "Add write watchpoint.",
         .func = cmd_add_breakpoint,
         .argc = 1,
@@ -102 +114 @@
 #endif /* CONFIG_KCONSOLE */
 
-/* Setup DR register according to table */
+/** Setup DR register according to table
+ *
+ */
 static void setup_dr(int curidx)
 {
-        unative_t dr7;
+        ASSERT(curidx >= 0);
+        
         bpinfo_t *cur = &breakpoints[curidx];
-        int flags = breakpoints[curidx].flags;
-
+        unsigned int flags = breakpoints[curidx].flags;
+        
         /* Disable breakpoint in DR7 */
-        dr7 = read_dr7();
-        dr7 &= ~(0x2 << (curidx*2));
-
-        if (cur->address) { /* Setup DR register */
+        unative_t dr7 = read_dr7();
+        dr7 &= ~(0x02U << (curidx * 2));
+        
+        /* Setup DR register */
+        if (cur->address) {
                 /* Set breakpoint to debug registers */
                 switch (curidx) {
@@ -129 +145 @@
                         break;
                 }
+                
                 /* Set type to requested breakpoint & length*/
-                dr7 &= ~ (0x3 << (16 + 4*curidx));
-                dr7 &= ~ (0x3 << (18 + 4*curidx));
-                if ((flags & BKPOINT_INSTR)) {
-                        ;
-                } else {
+                dr7 &= ~(0x03U << (16 + 4 * curidx));
+                dr7 &= ~(0x03U << (18 + 4 * curidx));
                 
+                if (!(flags & BKPOINT_INSTR)) {
 #ifdef __32_BITS__
-                        dr7 |= ((unative_t) 0x3) << (18 + 4 * curidx);
-#endif
-
+                        dr7 |= ((unative_t) 0x03U) << (18 + 4 * curidx);
+#endif
+                        
 #ifdef __64_BITS__
-                        dr7 |= ((unative_t) 0x2) << (18 + 4 * curidx);
+                        dr7 |= ((unative_t) 0x02U) << (18 + 4 * curidx);
 #endif
                         
                         if ((flags & BKPOINT_WRITE))
-                                dr7 |= ((unative_t) 0x1) << (16 + 4 * curidx);
+                                dr7 |= ((unative_t) 0x01U) << (16 + 4 * curidx);
                         else if ((flags & BKPOINT_READ_WRITE))
-                                dr7 |= ((unative_t) 0x3) << (16 + 4 * curidx);
-                }
-
+                                dr7 |= ((unative_t) 0x03U) << (16 + 4 * curidx);
+                }
+                
                 /* Enable global breakpoint */
-                dr7 |= 0x2 << (curidx * 2);
-
+                dr7 |= 0x02U << (curidx * 2);
+                
                 write_dr7(dr7);
-                
-        } 
-}
-        
+        }
+}
+
 /** Enable hardware breakpoint
  *
  * @param where Address of HW breakpoint
  * @param flags Type of breakpoint (EXECUTE, WRITE)
+ *
  * @return Debug slot on success, -1 - no available HW breakpoint
- */
-int breakpoint_add(const void *where, const int flags, int curidx)
-{
-        ipl_t ipl;
-        int i;
-        bpinfo_t *cur;
-
+ *
+ */
+int breakpoint_add(const void *where, const unsigned int flags, int curidx)
+{
         ASSERT(flags & (BKPOINT_INSTR | BKPOINT_WRITE | BKPOINT_READ_WRITE));
-
-        ipl = interrupts_disable();
-        spinlock_lock(&bkpoint_lock);
+        
+        irq_spinlock_lock(&bkpoint_lock, true);
         
         if (curidx == -1) {
                 /* Find free space in slots */
-                for (i = 0; i < BKPOINTS_MAX; i++)
+                unsigned int i;
+                for (i = 0; i < BKPOINTS_MAX; i++) {
                         if (!breakpoints[i].address) {
                                 curidx = i;
                                 break;
                         }
+                }
+                
                 if (curidx == -1) {
                         /* Too many breakpoints */
-                        spinlock_unlock(&bkpoint_lock);
-                        interrupts_restore(ipl);
+                        irq_spinlock_unlock(&bkpoint_lock, true);
                         return -1;
                 }
         }
-        cur = &breakpoints[curidx];
-
+        
+        bpinfo_t *cur = &breakpoints[curidx];
+        
         cur->address = (uintptr_t) where;
         cur->flags = flags;
         cur->counter = 0;
-
+        
         setup_dr(curidx);
-
-        spinlock_unlock(&bkpoint_lock);
-        interrupts_restore(ipl);
-
+        
+        irq_spinlock_unlock(&bkpoint_lock, true);
+        
         /* Send IPI */
-#ifdef CONFIG_SMP
 //      ipi_broadcast(VECTOR_DEBUG_IPI);
-#endif  
-
+        
         return curidx;
 }
 
-#ifdef __64_BITS__
-        #define getip(x)  ((x)->rip)
-#else
-        #define getip(x)  ((x)->eip)
-#endif
-
 static void handle_exception(int slot, istate_t *istate)
 {
+        ASSERT(slot >= 0);
         ASSERT(breakpoints[slot].address);
-
+        
         /* Handle zero checker */
-        if (! (breakpoints[slot].flags & BKPOINT_INSTR)) {
+        if (!(breakpoints[slot].flags & BKPOINT_INSTR)) {
                 if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) {
                         if (*((unative_t *) breakpoints[slot].address) != 0)
                                 return;
-                        printf("*** Found ZERO on address %lx (slot %d) ***\n",
-                            breakpoints[slot].address, slot);
+                        
+                        printf("*** Found ZERO on address %p (slot %d) ***\n",
+                            (void *) breakpoints[slot].address, slot);
                 } else {
-                        printf("Data watchpoint - new data: %lx\n",
+                        printf("Data watchpoint - new data: %#" PRIxn "\n",
                             *((unative_t *) breakpoints[slot].address));
                 }
         }
-
-        printf("Reached breakpoint %d:%lx (%s)\n", slot, getip(istate),
-            symtab_fmt_name_lookup(getip(istate)));
-
+        
+        printf("Reached breakpoint %d:%p (%s)\n", slot,
+            (void *) getip(istate), symtab_fmt_name_lookup(getip(istate)));
+        
 #ifdef CONFIG_KCONSOLE
         atomic_set(&haltstate, 1);
@@ -243 +250 @@
 void breakpoint_del(int slot)
 {
-        bpinfo_t *cur;
-        ipl_t ipl;
-
-        ipl = interrupts_disable();
-        spinlock_lock(&bkpoint_lock);
-
-        cur = &breakpoints[slot];
+        ASSERT(slot >= 0);
+        
+        irq_spinlock_lock(&bkpoint_lock, true);
+        
+        bpinfo_t *cur = &breakpoints[slot];
         if (!cur->address) {
-                spinlock_unlock(&bkpoint_lock);
-                interrupts_restore(ipl);
+                irq_spinlock_unlock(&bkpoint_lock, true);
                 return;
         }
-
-        cur->address = NULL;
-
+        
+        cur->address = (uintptr_t) NULL;
+        
         setup_dr(slot);
-
-        spinlock_unlock(&bkpoint_lock);
-        interrupts_restore(ipl);
-#ifdef CONFIG_SMP
-//      ipi_broadcast(VECTOR_DEBUG_IPI);        
-#endif
-}
-
-
-
-static void debug_exception(int n __attribute__((unused)), istate_t *istate)
-{
-        unative_t dr6;
-        int i;
-        
+        
+        irq_spinlock_unlock(&bkpoint_lock, true);
+//      ipi_broadcast(VECTOR_DEBUG_IPI);
+}
+
+static void debug_exception(unsigned int n __attribute__((unused)), istate_t *istate)
+{
         /* Set RF to restart the instruction  */
 #ifdef __64_BITS__
         istate->rflags |= RFLAGS_RF;
-#else
+#endif
+        
+#ifdef __32_BITS__
         istate->eflags |= EFLAGS_RF;
 #endif
-
-        dr6 = read_dr6();
-        for (i=0; i < BKPOINTS_MAX; i++) {
+        
+        unative_t dr6 = read_dr6();
+        
+        unsigned int i;
+        for (i = 0; i < BKPOINTS_MAX; i++) {
                 if (dr6 & (1 << i)) {
                         dr6 &= ~ (1 << i);
@@ -293 +293 @@
 
 #ifdef CONFIG_SMP
-static void
-debug_ipi(int n __attribute__((unused)),
+static void debug_ipi(unsigned int n __attribute__((unused)),
     istate_t *istate __attribute__((unused)))
 {
-        int i;
-
-        spinlock_lock(&bkpoint_lock);
+        irq_spinlock_lock(&bkpoint_lock, false);
+        
+        unsigned int i;
         for (i = 0; i < BKPOINTS_MAX; i++)
                 setup_dr(i);
-        spinlock_unlock(&bkpoint_lock);
-}
-#endif
-
-/** Initialize debugger */
+        
+        irq_spinlock_unlock(&bkpoint_lock, false);
+}
+#endif /* CONFIG_SMP */
+
+/** Initialize debugger
+ *
+ */
 void debugger_init()
 {
-        int i;
-
+        unsigned int i;
         for (i = 0; i < BKPOINTS_MAX; i++)
-                breakpoints[i].address = NULL;
-
+                breakpoints[i].address = (uintptr_t) NULL;
+        
 #ifdef CONFIG_KCONSOLE
         cmd_initialize(&bkpts_info);
         if (!cmd_register(&bkpts_info))
                 printf("Cannot register command %s\n", bkpts_info.name);
-
+        
         cmd_initialize(&delbkpt_info);
         if (!cmd_register(&delbkpt_info))
                 printf("Cannot register command %s\n", delbkpt_info.name);
-
+        
         cmd_initialize(&addbkpt_info);
         if (!cmd_register(&addbkpt_info))
                 printf("Cannot register command %s\n", addbkpt_info.name);
-
+        
         cmd_initialize(&addwatchp_info);
         if (!cmd_register(&addwatchp_info))
@@ -332 +333 @@
 #endif /* CONFIG_KCONSOLE */
         
-        exc_register(VECTOR_DEBUG, "debugger", debug_exception);
+        exc_register(VECTOR_DEBUG, "debugger", true,
+            debug_exception);
+        
 #ifdef CONFIG_SMP
-        exc_register(VECTOR_DEBUG_IPI, "debugger_smp", debug_ipi);
-#endif
+        exc_register(VECTOR_DEBUG_IPI, "debugger_smp", true,
+            debug_ipi);
+#endif /* CONFIG_SMP */
 }
 
 #ifdef CONFIG_KCONSOLE
-/** Print table of active breakpoints */
+/** Print table of active breakpoints
+ *
+ */
 int cmd_print_breakpoints(cmd_arg_t *argv __attribute__((unused)))
 {
+#ifdef __32_BITS__
+        printf("[nr] [count] [address ] [in symbol\n");
+#endif
+        
+#ifdef __64_BITS__
+        printf("[nr] [count] [address         ] [in symbol\n");
+#endif
+        
         unsigned int i;
-        char *symbol;
-
+        for (i = 0; i < BKPOINTS_MAX; i++) {
+                if (breakpoints[i].address) {
+                        const char *symbol = symtab_fmt_name_lookup(
+                            breakpoints[i].address);
+                        
 #ifdef __32_BITS__
-        printf("#  Count Address    In symbol\n");
-        printf("-- ----- ---------- ---------\n");
-#endif
-
+                        printf("%-4u %7zu %p %s\n", i,
+                            breakpoints[i].counter, (void *) breakpoints[i].address,
+                            symbol);
+#endif
+                        
 #ifdef __64_BITS__
-        printf("#  Count Address            In symbol\n");
-        printf("-- ----- ------------------ ---------\n");
-#endif
-        
-        for (i = 0; i < BKPOINTS_MAX; i++)
-                if (breakpoints[i].address) {
-                        symbol = symtab_fmt_name_lookup(
-                            breakpoints[i].address);
-
-#ifdef __32_BITS__
-                        printf("%-2u %-5d %#10zx %s\n", i,
-                            breakpoints[i].counter, breakpoints[i].address,
+                        printf("%-4u %7zu %p %s\n", i,
+                            breakpoints[i].counter, (void *) breakpoints[i].address,
                             symbol);
 #endif
-
-#ifdef __64_BITS__
-                        printf("%-2u %-5d %#18zx %s\n", i,
-                            breakpoints[i].counter, breakpoints[i].address,
-                            symbol);
-#endif
-
-                }
+                }
+        }
+        
         return 1;
 }
 
-/** Remove breakpoint from table */
+/** Remove breakpoint from table
+ *
+ */
 int cmd_del_breakpoint(cmd_arg_t *argv)
 {
@@ -384 +389 @@
                 return 0;
         }
+        
         breakpoint_del(argv->intval);
         return 1;
 }
 
-/** Add new breakpoint to table */
+/** Add new breakpoint to table
+ *
+ */
 static int cmd_add_breakpoint(cmd_arg_t *argv)
 {
-        int flags;
-        int id;
-
-        if (argv == &add_argv) {
+        unsigned int flags;
+        if (argv == &add_argv)
                 flags = BKPOINT_INSTR;
-        } else { /* addwatchp */
+        else
                 flags = BKPOINT_WRITE;
-        }
-        printf("Adding breakpoint on address: %p\n", argv->intval);
-        id = breakpoint_add((void *)argv->intval, flags, -1);
+        
+        printf("Adding breakpoint on address: %p\n",
+            (void *) argv->intval);
+        
+        int id = breakpoint_add((void *) argv->intval, flags, -1);
         if (id < 0)
                 printf("Add breakpoint failed.\n");

kernel/arch/amd64/src/delay.S

@@ -37 +37 @@
 
 asm_delay_loop:
-0:      dec %rdi
-        jnz 0b
+        0:
+                dec %rdi
+                jnz 0b
+        
         ret
 
 asm_fake_loop:
-0:      dec %rdi
-        jz 0b
+        0:
+                dec %rdi
+                jz 0b
+        
         ret

kernel/arch/amd64/src/fpu_context.c

@@ -27 +27 @@
  */
 
-/** @addtogroup amd64   
+/** @addtogroup amd64
  * @{
  */

kernel/arch/amd64/src/interrupt.c

@@ -63 +63 @@
 void (* eoi_function)(void) = NULL;
 
-void decode_istate(int n, istate_t *istate)
-{
-        char *symbol;
-
-        symbol = symtab_fmt_name_lookup(istate->rip);
-
-        printf("-----EXCEPTION(%d) OCCURED----- ( %s )\n", n, __func__);
-        printf("%%rip: %#llx (%s)\n", istate->rip, symbol);
-        printf("ERROR_WORD=%#llx\n", istate->error_word);
-        printf("%%cs=%#llx, rflags=%#llx, %%cr0=%#llx\n", istate->cs,
-            istate->rflags, read_cr0());
-        printf("%%rax=%#llx, %%rcx=%#llx, %%rdx=%#llx\n", istate->rax,
-            istate->rcx, istate->rdx);
-        printf("%%rsi=%#llx, %%rdi=%#llx, %%r8=%#llx\n", istate->rsi,
-            istate->rdi, istate->r8);
-        printf("%%r9=%#llx, %%r10=%#llx, %%r11=%#llx\n", istate->r9,
-            istate->r10, istate->r11);
-        printf("%%rsp=%#llx\n", &istate->stack[0]);
-        
-        stack_trace_istate(istate);
+void istate_decode(istate_t *istate)
+{
+        printf("cs =%#0" PRIx64 "\trip=%p\t"
+            "rfl=%#0" PRIx64 "\terr=%#0" PRIx64 "\n",
+            istate->cs, (void *) istate->rip,
+            istate->rflags, istate->error_word);
+        
+        if (istate_from_uspace(istate))
+                printf("ss =%#0" PRIx64 "\n", istate->ss);
+        
+        printf("rax=%#0" PRIx64 "\trbx=%#0" PRIx64 "\t"
+            "rcx=%#0" PRIx64 "\trdx=%#0" PRIx64 "\n",
+            istate->rax, istate->rbx, istate->rcx, istate->rdx);
+        
+        printf("rsi=%p\trdi=%p\trbp=%p\trsp=%p\n",
+            (void *) istate->rsi, (void *) istate->rdi,
+            (void *) istate->rbp,
+            istate_from_uspace(istate) ? ((void *) istate->rsp) :
+            &istate->rsp);
+        
+        printf("r8 =%#0" PRIx64 "\tr9 =%#0" PRIx64 "\t"
+            "r10=%#0" PRIx64 "\tr11=%#0" PRIx64 "\n",
+            istate->r8, istate->r9, istate->r10, istate->r11);
+        
+        printf("r12=%#0" PRIx64 "\tr13=%#0" PRIx64 "\t"
+            "r14=%#0" PRIx64 "\tr15=%#0" PRIx64 "\n",
+            istate->r12, istate->r13, istate->r14, istate->r15);
 }
 
@@ -94 +101 @@
 }
 
-static void null_interrupt(int n, istate_t *istate)
-{
-        fault_if_from_uspace(istate, "Unserviced interrupt: %d.", n);
-        decode_istate(n, istate);
-        panic("Unserviced interrupt.");
-}
-
-static void de_fault(int n, istate_t *istate)
+static void null_interrupt(unsigned int n, istate_t *istate)
+{
+        fault_if_from_uspace(istate, "Unserviced interrupt: %u.", n);
+        panic_badtrap(istate, n, "Unserviced interrupt.");
+}
+
+static void de_fault(unsigned int n, istate_t *istate)
 {
         fault_if_from_uspace(istate, "Divide error.");
-        decode_istate(n, istate);
-        panic("Divide error.");
-}
-
-/** General Protection Fault. */
-static void gp_fault(int n, istate_t *istate)
+        panic_badtrap(istate, n, "Divide error.");
+}
+
+/** General Protection Fault.
+ *
+ */
+static void gp_fault(unsigned int n, istate_t *istate)
 {
         if (TASK) {
-                size_t ver;
-
-                spinlock_lock(&TASK->lock);
-                ver = TASK->arch.iomapver;
-                spinlock_unlock(&TASK->lock);
-
+                irq_spinlock_lock(&TASK->lock, false);
+                size_t ver = TASK->arch.iomapver;
+                irq_spinlock_unlock(&TASK->lock, false);
+                
                 if (CPU->arch.iomapver_copy != ver) {
                         /*
@@ -131 +136 @@
                 fault_if_from_uspace(istate, "General protection fault.");
         }
-
-        decode_istate(n, istate);
-        panic("General protection fault.");
-}
-
-static void ss_fault(int n, istate_t *istate)
+        panic_badtrap(istate, n, "General protection fault.");
+}
+
+static void ss_fault(unsigned int n, istate_t *istate)
 {
         fault_if_from_uspace(istate, "Stack fault.");
-        decode_istate(n, istate);
-        panic("Stack fault.");
-}
-
-static void nm_fault(int n, istate_t *istate)
+        panic_badtrap(istate, n, "Stack fault.");
+}
+
+static void nm_fault(unsigned int n, istate_t *istate)
 {
 #ifdef CONFIG_FPU_LAZY
@@ -154 +156 @@
 
 #ifdef CONFIG_SMP
-static void tlb_shootdown_ipi(int n, istate_t *istate)
+static void tlb_shootdown_ipi(unsigned int n, istate_t *istate)
 {
         trap_virtual_eoi();
@@ -161 +163 @@
 #endif
 
-/** Handler of IRQ exceptions */
-static void irq_interrupt(int n, istate_t *istate)
+/** Handler of IRQ exceptions.
+ *
+ */
+static void irq_interrupt(unsigned int n, istate_t *istate)
 {
         ASSERT(n >= IVT_IRQBASE);
         
-        int inum = n - IVT_IRQBASE;
+        unsigned int inum = n - IVT_IRQBASE;
         bool ack = false;
         ASSERT(inum < IRQ_COUNT);
@@ -176 +180 @@
                  * The IRQ handler was found.
                  */
-                 
+                
                 if (irq->preack) {
                         /* Send EOI before processing the interrupt */
@@ -183 +187 @@
                 }
                 irq->handler(irq);
-                spinlock_unlock(&irq->lock);
+                irq_spinlock_unlock(&irq->lock, false);
         } else {
                 /*
@@ -189 +193 @@
                  */
 #ifdef CONFIG_DEBUG
-                printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum);
+                printf("cpu%u: spurious interrupt (inum=%u)\n", CPU->id, inum);
 #endif
         }
@@ -199 +203 @@
 void interrupt_init(void)
 {
-        int i;
+        unsigned int i;
         
         for (i = 0; i < IVT_ITEMS; i++)
-                exc_register(i, "null", (iroutine) null_interrupt);
+                exc_register(i, "null", false, (iroutine_t) null_interrupt);
         
         for (i = 0; i < IRQ_COUNT; i++) {
                 if ((i != IRQ_PIC_SPUR) && (i != IRQ_PIC1))
-                        exc_register(IVT_IRQBASE + i, "irq",
-                            (iroutine) irq_interrupt);
+                        exc_register(IVT_IRQBASE + i, "irq", true,
+                            (iroutine_t) irq_interrupt);
         }
         
-        exc_register(0, "de_fault", (iroutine) de_fault);
-        exc_register(7, "nm_fault", (iroutine) nm_fault);
-        exc_register(12, "ss_fault", (iroutine) ss_fault);
-        exc_register(13, "gp_fault", (iroutine) gp_fault);
-        exc_register(14, "ident_mapper", (iroutine) ident_page_fault);
+        exc_register(0, "de_fault", true, (iroutine_t) de_fault);
+        exc_register(7, "nm_fault", true, (iroutine_t) nm_fault);
+        exc_register(12, "ss_fault", true, (iroutine_t) ss_fault);
+        exc_register(13, "gp_fault", true, (iroutine_t) gp_fault);
         
 #ifdef CONFIG_SMP
-        exc_register(VECTOR_TLB_SHOOTDOWN_IPI, "tlb_shootdown",
-            (iroutine) tlb_shootdown_ipi);
+        exc_register(VECTOR_TLB_SHOOTDOWN_IPI, "tlb_shootdown", true,
+            (iroutine_t) tlb_shootdown_ipi);
 #endif
 }

kernel/arch/amd64/src/mm/page.c

@@ -39 +39 @@
 #include <mm/frame.h>
 #include <mm/as.h>
-#include <arch/interrupt.h>
 #include <arch/asm.h>
 #include <config.h>
@@ -48 +47 @@
 #include <align.h>
 
-/* Definitions for identity page mapper */
-pte_t helper_ptl1[512] __attribute__((aligned (PAGE_SIZE)));
-pte_t helper_ptl2[512] __attribute__((aligned (PAGE_SIZE)));
-pte_t helper_ptl3[512] __attribute__((aligned (PAGE_SIZE)));
-extern pte_t ptl_0; /* From boot.S */
-
-#define PTL1_PRESENT(ptl0, page) (!(GET_PTL1_FLAGS_ARCH(ptl0, PTL0_INDEX_ARCH(page)) & PAGE_NOT_PRESENT))
-#define PTL2_PRESENT(ptl1, page) (!(GET_PTL2_FLAGS_ARCH(ptl1, PTL1_INDEX_ARCH(page)) & PAGE_NOT_PRESENT))
-#define PTL3_PRESENT(ptl2, page) (!(GET_PTL3_FLAGS_ARCH(ptl2, PTL2_INDEX_ARCH(page)) & PAGE_NOT_PRESENT))
-
-#define PTL1_ADDR(ptl0, page) ((pte_t *)PA2KA(GET_PTL1_ADDRESS_ARCH(ptl0, PTL0_INDEX_ARCH(page))))
-#define PTL2_ADDR(ptl1, page) ((pte_t *)PA2KA(GET_PTL2_ADDRESS_ARCH(ptl1, PTL1_INDEX_ARCH(page))))
-#define PTL3_ADDR(ptl2, page) ((pte_t *)PA2KA(GET_PTL3_ADDRESS_ARCH(ptl2, PTL2_INDEX_ARCH(page))))
-
-#define SETUP_PTL1(ptl0, page, tgt)  {  \
-        SET_PTL1_ADDRESS_ARCH(ptl0, PTL0_INDEX_ARCH(page), (uintptr_t)KA2PA(tgt)); \
-        SET_PTL1_FLAGS_ARCH(ptl0, PTL0_INDEX_ARCH(page), PAGE_WRITE | PAGE_EXEC); \
-    }
-#define SETUP_PTL2(ptl1, page, tgt)  {  \
-        SET_PTL2_ADDRESS_ARCH(ptl1, PTL1_INDEX_ARCH(page), (uintptr_t)KA2PA(tgt)); \
-        SET_PTL2_FLAGS_ARCH(ptl1, PTL1_INDEX_ARCH(page), PAGE_WRITE | PAGE_EXEC); \
-    }
-#define SETUP_PTL3(ptl2, page, tgt)  {  \
-        SET_PTL3_ADDRESS_ARCH(ptl2, PTL2_INDEX_ARCH(page), (uintptr_t)KA2PA(tgt)); \
-        SET_PTL3_FLAGS_ARCH(ptl2, PTL2_INDEX_ARCH(page), PAGE_WRITE | PAGE_EXEC); \
-    }
-#define SETUP_FRAME(ptl3, page, tgt)  { \
-        SET_FRAME_ADDRESS_ARCH(ptl3, PTL3_INDEX_ARCH(page), (uintptr_t)KA2PA(tgt)); \
-        SET_FRAME_FLAGS_ARCH(ptl3, PTL3_INDEX_ARCH(page), PAGE_WRITE | PAGE_EXEC); \
-    }
-
-
 void page_arch_init(void)
 {
-        uintptr_t cur;
-        unsigned int i;
-        int identity_flags = PAGE_CACHEABLE | PAGE_EXEC | PAGE_GLOBAL | PAGE_WRITE;
-
         if (config.cpu_active == 1) {
+                uintptr_t cur;
+                unsigned int identity_flags =
+                    PAGE_CACHEABLE | PAGE_EXEC | PAGE_GLOBAL | PAGE_WRITE;
+                
                 page_mapping_operations = &pt_mapping_operations;
-
+                
+                page_table_lock(AS_KERNEL, true);
+                
                 /*
                  * PA2KA(identity) mapping for all frames.
                  */
-                for (cur = 0; cur < last_frame; cur += FRAME_SIZE) {
-                        /* Standard identity mapping */
+                for (cur = 0; cur < last_frame; cur += FRAME_SIZE)
                         page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, identity_flags);
-                }
                 
-                /* Upper kernel mapping
-                 * - from zero to top of kernel (include bottom addresses
-                 *   because some are needed for init)
-                 */
-                for (cur = PA2KA_CODE(0); cur < config.base + config.kernel_size; cur += FRAME_SIZE)
-                        page_mapping_insert(AS_KERNEL, cur, KA2PA(cur), identity_flags);
+                page_table_unlock(AS_KERNEL, true);
                 
-                for (cur = config.stack_base; cur < config.stack_base + config.stack_size; cur += FRAME_SIZE)
-                        page_mapping_insert(AS_KERNEL, cur, KA2PA(cur), identity_flags);
-                
-                for (i = 0; i < init.cnt; i++) {
-                        for (cur = init.tasks[i].addr; cur < init.tasks[i].addr + init.tasks[i].size; cur += FRAME_SIZE)
-                                page_mapping_insert(AS_KERNEL, PA2KA_CODE(KA2PA(cur)), KA2PA(cur), identity_flags);
-                }
-
-                exc_register(14, "page_fault", (iroutine) page_fault);
+                exc_register(14, "page_fault", true, (iroutine_t) page_fault);
                 write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
-        } else 
+        } else
                 write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
 }
 
-
-/** Identity page mapper
- *
- * We need to map whole physical memory identically before the page subsystem
- * is initializaed. This thing clears page table and fills in the specific
- * items.
- */
-void ident_page_fault(int n, istate_t *istate)
+void page_fault(unsigned int n, istate_t *istate)
 {
-        uintptr_t page;
-        static uintptr_t oldpage = 0;
-        pte_t *aptl_1, *aptl_2, *aptl_3;
-
-        page = read_cr2();
-        if (oldpage) {
-                /* Unmap old address */
-                aptl_1 = PTL1_ADDR(&ptl_0, oldpage);
-                aptl_2 = PTL2_ADDR(aptl_1, oldpage);
-                aptl_3 = PTL3_ADDR(aptl_2, oldpage);
-
-                SET_FRAME_FLAGS_ARCH(aptl_3, PTL3_INDEX_ARCH(oldpage), PAGE_NOT_PRESENT);
-                if (KA2PA(aptl_3) == KA2PA(helper_ptl3))
-                        SET_PTL3_FLAGS_ARCH(aptl_2, PTL2_INDEX_ARCH(oldpage), PAGE_NOT_PRESENT);
-                if (KA2PA(aptl_2) == KA2PA(helper_ptl2))
-                        SET_PTL2_FLAGS_ARCH(aptl_1, PTL1_INDEX_ARCH(oldpage), PAGE_NOT_PRESENT);
-                if (KA2PA(aptl_1) == KA2PA(helper_ptl1))
-                        SET_PTL1_FLAGS_ARCH(&ptl_0, PTL0_INDEX_ARCH(oldpage), PAGE_NOT_PRESENT);
-        }
-        if (PTL1_PRESENT(&ptl_0, page))
-                aptl_1 = PTL1_ADDR(&ptl_0, page);
-        else {
-                SETUP_PTL1(&ptl_0, page, helper_ptl1);
-                aptl_1 = helper_ptl1;
-        }
-            
-        if (PTL2_PRESENT(aptl_1, page)) 
-                aptl_2 = PTL2_ADDR(aptl_1, page);
-        else {
-                SETUP_PTL2(aptl_1, page, helper_ptl2);
-                aptl_2 = helper_ptl2;
-        }
-
-        if (PTL3_PRESENT(aptl_2, page))
-                aptl_3 = PTL3_ADDR(aptl_2, page);
-        else {
-                SETUP_PTL3(aptl_2, page, helper_ptl3);
-                aptl_3 = helper_ptl3;
-        }
-        
-        SETUP_FRAME(aptl_3, page, page);
-
-        oldpage = page;
-}
-
-
-void page_fault(int n, istate_t *istate)
-{
-        uintptr_t page;
-        pf_access_t access;
-        
-        page = read_cr2();
+        uintptr_t page = read_cr2();
         
         if (istate->error_word & PFERR_CODE_RSVD)
                 panic("Reserved bit set in page table entry.");
+        
+        pf_access_t access;
         
         if (istate->error_word & PFERR_CODE_RW)
@@ -191 +89 @@
         
         if (as_page_fault(page, access, istate) == AS_PF_FAULT) {
-                fault_if_from_uspace(istate, "Page fault: %#x.", page);
-
-                decode_istate(n, istate);
-                printf("Page fault address: %llx.\n", page);
-                panic("Page fault.");
+                fault_if_from_uspace(istate, "Page fault: %p.", (void *) page);
+                panic_memtrap(istate, access, page, NULL);
         }
 }
-
 
 uintptr_t hw_map(uintptr_t physaddr, size_t size)
 {
         if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
-                panic("Unable to map physical memory %p (%d bytes).", physaddr,
-                    size);
+                panic("Unable to map physical memory %p (%zu bytes).",
+                    (void *) physaddr, size);
         
         uintptr_t virtaddr = PA2KA(last_frame);
         pfn_t i;
+        
+        page_table_lock(AS_KERNEL, true);
+        
         for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
                 page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE | PAGE_WRITE);
+        
+        page_table_unlock(AS_KERNEL, true);
         
         last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);

kernel/arch/amd64/src/pm.c

@@ -28 +28 @@
  */
 
-/** @addtogroup amd64   
+/** @addtogroup amd64
  * @{
  */
@@ -52 +52 @@
         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
         /* KTEXT descriptor */
-        { .limit_0_15  = 0xffff, 
-          .base_0_15   = 0, 
-          .base_16_23  = 0, 
-          .access      = AR_PRESENT | AR_CODE | DPL_KERNEL | AR_READABLE, 
-          .limit_16_19 = 0xf, 
-          .available   = 0, 
-          .longmode    = 1, 
+        { .limit_0_15  = 0xffffU,
+          .base_0_15   = 0,
+          .base_16_23  = 0,
+          .access      = AR_PRESENT | AR_CODE | DPL_KERNEL | AR_READABLE,
+          .limit_16_19 = 0x0fU,
+          .available   = 0,
+          .longmode    = 1,
           .special     = 0,
-          .granularity = 1, 
+          .granularity = 1,
           .base_24_31  = 0 },
         /* KDATA descriptor */
-        { .limit_0_15  = 0xffff, 
-          .base_0_15   = 0, 
-          .base_16_23  = 0, 
-          .access      = AR_PRESENT | AR_DATA | AR_WRITABLE | DPL_KERNEL, 
-          .limit_16_19 = 0xf, 
-          .available   = 0, 
-          .longmode    = 0, 
-          .special     = 0, 
-          .granularity = 1, 
+        { .limit_0_15  = 0xffffU,
+          .base_0_15   = 0,
+          .base_16_23  = 0,
+          .access      = AR_PRESENT | AR_DATA | AR_WRITABLE | DPL_KERNEL,
+          .limit_16_19 = 0x0fU,
+          .available   = 0,
+          .longmode    = 0,
+          .special     = 0,
+          .granularity = 1,
           .base_24_31  = 0 },
         /* UDATA descriptor */
-        { .limit_0_15  = 0xffff, 
-          .base_0_15   = 0, 
-          .base_16_23  = 0, 
-          .access      = AR_PRESENT | AR_DATA | AR_WRITABLE | DPL_USER, 
-          .limit_16_19 = 0xf, 
-          .available   = 0, 
-          .longmode    = 0, 
-          .special     = 1, 
-          .granularity = 1, 
+        { .limit_0_15  = 0xffffU,
+          .base_0_15   = 0,
+          .base_16_23  = 0,
+          .access      = AR_PRESENT | AR_DATA | AR_WRITABLE | DPL_USER,
+          .limit_16_19 = 0x0fU,
+          .available   = 0,
+          .longmode    = 0,
+          .special     = 1,
+          .granularity = 1,
           .base_24_31  = 0 },
         /* UTEXT descriptor */
-        { .limit_0_15  = 0xffff, 
-          .base_0_15   = 0, 
-          .base_16_23  = 0, 
-          .access      = AR_PRESENT | AR_CODE | DPL_USER, 
-          .limit_16_19 = 0xf, 
-          .available   = 0, 
-          .longmode    = 1, 
-          .special     = 0, 
-          .granularity = 1, 
+        { .limit_0_15  = 0xffffU,
+          .base_0_15   = 0,
+          .base_16_23  = 0,
+          .access      = AR_PRESENT | AR_CODE | DPL_USER,
+          .limit_16_19 = 0x0fU,
+          .available   = 0,
+          .longmode    = 1,
+          .special     = 0,
+          .granularity = 1,
           .base_24_31  = 0 },
         /* KTEXT 32-bit protected, for protected mode before long mode */
-        { .limit_0_15  = 0xffff, 
-          .base_0_15   = 0, 
-          .base_16_23  = 0, 
-          .access      = AR_PRESENT | AR_CODE | DPL_KERNEL | AR_READABLE, 
-          .limit_16_19 = 0xf, 
-          .available   = 0, 
-          .longmode    = 0, 
+        { .limit_0_15  = 0xffffU,
+          .base_0_15   = 0,
+          .base_16_23  = 0,
+          .access      = AR_PRESENT | AR_CODE | DPL_KERNEL | AR_READABLE,
+          .limit_16_19 = 0x0fU,
+          .available   = 0,
+          .longmode    = 0,
           .special     = 1,
-          .granularity = 1, 
+          .granularity = 1,
           .base_24_31  = 0 },
         /* TSS descriptor - set up will be completed later,
@@ -111 +111 @@
         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
         /* VESA Init descriptor */
-#ifdef CONFIG_FB        
-        { 0xffff, 0, VESA_INIT_SEGMENT >> 12, AR_PRESENT | AR_CODE | DPL_KERNEL,
-          0xf, 0, 0, 0, 0, 0
+#ifdef CONFIG_FB
+        {
+                0xffff, 0, VESA_INIT_SEGMENT >> 12, AR_PRESENT | AR_CODE | DPL_KERNEL,
+                    0xf, 0, 0, 0, 0, 0
         }
 #endif
@@ -129 +130 @@
 {
         tss_descriptor_t *td = (tss_descriptor_t *) d;
-
-        td->base_0_15 = base & 0xffff;
-        td->base_16_23 = ((base) >> 16) & 0xff;
-        td->base_24_31 = ((base) >> 24) & 0xff;
+        
+        td->base_0_15 = base & 0xffffU;
+        td->base_16_23 = ((base) >> 16) & 0xffU;
+        td->base_24_31 = ((base) >> 24) & 0xffU;
         td->base_32_63 = ((base) >> 32);
 }
@@ -140 +141 @@
         tss_descriptor_t *td = (tss_descriptor_t *) d;
         
-        td->limit_0_15 = limit & 0xffff;
-        td->limit_16_19 = (limit >> 16) & 0xf;
+        td->limit_0_15 = limit & 0xffffU;
+        td->limit_16_19 = (limit >> 16) & 0x0fU;
 }
 
@@ -149 +150 @@
          * Offset is a linear address.
          */
-        d->offset_0_15 = offset & 0xffff;
-        d->offset_16_31 = offset >> 16 & 0xffff;
+        d->offset_0_15 = offset & 0xffffU;
+        d->offset_16_31 = (offset >> 16) & 0xffffU;
         d->offset_32_63 = offset >> 32;
 }
@@ -165 +166 @@
 {
         idescriptor_t *d;
-        int i;
-
+        unsigned int i;
+        
         for (i = 0; i < IDT_ITEMS; i++) {
                 d = &idt[i];
-
+                
                 d->unused = 0;
-                d->selector = gdtselector(KTEXT_DES);
-
+                d->selector = GDT_SELECTOR(KTEXT_DES);
+                
                 d->present = 1;
-                d->type = AR_INTERRUPT; /* masking interrupt */
-
-                idt_setoffset(d, ((uintptr_t) interrupt_handlers) +
-                    i * interrupt_handler_size);
+                d->type = AR_INTERRUPT;  /* masking interrupt */
         }
+        
+        d = &idt[0];
+        idt_setoffset(d++, (uintptr_t) &int_0);
+        idt_setoffset(d++, (uintptr_t) &int_1);
+        idt_setoffset(d++, (uintptr_t) &int_2);
+        idt_setoffset(d++, (uintptr_t) &int_3);
+        idt_setoffset(d++, (uintptr_t) &int_4);
+        idt_setoffset(d++, (uintptr_t) &int_5);
+        idt_setoffset(d++, (uintptr_t) &int_6);
+        idt_setoffset(d++, (uintptr_t) &int_7);
+        idt_setoffset(d++, (uintptr_t) &int_8);
+        idt_setoffset(d++, (uintptr_t) &int_9);
+        idt_setoffset(d++, (uintptr_t) &int_10);
+        idt_setoffset(d++, (uintptr_t) &int_11);
+        idt_setoffset(d++, (uintptr_t) &int_12);
+        idt_setoffset(d++, (uintptr_t) &int_13);
+        idt_setoffset(d++, (uintptr_t) &int_14);
+        idt_setoffset(d++, (uintptr_t) &int_15);
+        idt_setoffset(d++, (uintptr_t) &int_16);
+        idt_setoffset(d++, (uintptr_t) &int_17);
+        idt_setoffset(d++, (uintptr_t) &int_18);
+        idt_setoffset(d++, (uintptr_t) &int_19);
+        idt_setoffset(d++, (uintptr_t) &int_20);
+        idt_setoffset(d++, (uintptr_t) &int_21);
+        idt_setoffset(d++, (uintptr_t) &int_22);
+        idt_setoffset(d++, (uintptr_t) &int_23);
+        idt_setoffset(d++, (uintptr_t) &int_24);
+        idt_setoffset(d++, (uintptr_t) &int_25);
+        idt_setoffset(d++, (uintptr_t) &int_26);
+        idt_setoffset(d++, (uintptr_t) &int_27);
+        idt_setoffset(d++, (uintptr_t) &int_28);
+        idt_setoffset(d++, (uintptr_t) &int_29);
+        idt_setoffset(d++, (uintptr_t) &int_30);
+        idt_setoffset(d++, (uintptr_t) &int_31);
+        idt_setoffset(d++, (uintptr_t) &int_32);
+        idt_setoffset(d++, (uintptr_t) &int_33);
+        idt_setoffset(d++, (uintptr_t) &int_34);
+        idt_setoffset(d++, (uintptr_t) &int_35);
+        idt_setoffset(d++, (uintptr_t) &int_36);
+        idt_setoffset(d++, (uintptr_t) &int_37);
+        idt_setoffset(d++, (uintptr_t) &int_38);
+        idt_setoffset(d++, (uintptr_t) &int_39);
+        idt_setoffset(d++, (uintptr_t) &int_40);
+        idt_setoffset(d++, (uintptr_t) &int_41);
+        idt_setoffset(d++, (uintptr_t) &int_42);
+        idt_setoffset(d++, (uintptr_t) &int_43);
+        idt_setoffset(d++, (uintptr_t) &int_44);
+        idt_setoffset(d++, (uintptr_t) &int_45);
+        idt_setoffset(d++, (uintptr_t) &int_46);
+        idt_setoffset(d++, (uintptr_t) &int_47);
+        idt_setoffset(d++, (uintptr_t) &int_48);
+        idt_setoffset(d++, (uintptr_t) &int_49);
+        idt_setoffset(d++, (uintptr_t) &int_50);
+        idt_setoffset(d++, (uintptr_t) &int_51);
+        idt_setoffset(d++, (uintptr_t) &int_52);
+        idt_setoffset(d++, (uintptr_t) &int_53);
+        idt_setoffset(d++, (uintptr_t) &int_54);
+        idt_setoffset(d++, (uintptr_t) &int_55);
+        idt_setoffset(d++, (uintptr_t) &int_56);
+        idt_setoffset(d++, (uintptr_t) &int_57);
+        idt_setoffset(d++, (uintptr_t) &int_58);
+        idt_setoffset(d++, (uintptr_t) &int_59);
+        idt_setoffset(d++, (uintptr_t) &int_60);
+        idt_setoffset(d++, (uintptr_t) &int_61);
+        idt_setoffset(d++, (uintptr_t) &int_62);
+        idt_setoffset(d++, (uintptr_t) &int_63);
 }
 
@@ -228 +292 @@
          * to its own TSS. We just need to load the TR register.
          */
-        tr_load(gdtselector(TSS_DES));
+        tr_load(GDT_SELECTOR(TSS_DES));
 }
 

kernel/arch/amd64/src/proc/scheduler.c

@@ -38 +38 @@
 #include <proc/thread.h>
 #include <arch.h>
-#include <arch/context.h>       /* SP_DELTA */
 #include <arch/asm.h>
 #include <print.h>
@@ -57 +56 @@
 {
         CPU->arch.tss->rsp0 =
-            (uintptr_t) &THREAD->kstack[THREAD_STACK_SIZE - SP_DELTA];
-
+            (uintptr_t) &THREAD->kstack[THREAD_STACK_SIZE];
+        
         /*
          * Syscall support.
          */
         swapgs();
-        write_msr(AMD_MSR_GS, (uintptr_t)THREAD->arch.syscall_rsp);
+        write_msr(AMD_MSR_GS, (uintptr_t) THREAD->arch.syscall_rsp);
         swapgs();
-
+        
         /* TLS support - set FS to thread local storage */
         write_msr(AMD_MSR_FS, THREAD->arch.tls);

kernel/arch/amd64/src/proc/task.c

@@ -35 +35 @@
 #include <proc/task.h>
 #include <mm/slab.h>
-#include <arch/types.h>
+#include <typedefs.h>
 
 /** Perform amd64 specific task initialization.
  *
- * @param t Task to be initialized.
+ * @param task Task to be initialized.
+ *
  */
-void task_create_arch(task_t *t)
+void task_create_arch(task_t *task)
 {
-        t->arch.iomapver = 0;
-        bitmap_initialize(&t->arch.iomap, NULL, 0);
+        task->arch.iomapver = 0;
+        bitmap_initialize(&task->arch.iomap, NULL, 0);
 }
 
 /** Perform amd64 specific task destruction.
  *
- * @param t Task to be initialized.
+ * @param task Task to be initialized.
+ *
  */
-void task_destroy_arch(task_t *t)
+void task_destroy_arch(task_t *task)
 {
-        if (t->arch.iomap.map)
-                free(t->arch.iomap.map);
+        if (task->arch.iomap.map)
+                free(task->arch.iomap.map);
 }
 

kernel/arch/amd64/src/proc/thread.c

@@ -34 +34 @@
 
 #include <proc/thread.h>
+#include <arch/interrupt.h>
 
 /** Perform amd64 specific thread initialization.
  *
- * @param t Thread to be initialized.
+ * @param thread Thread to be initialized.
+ *
  */
-void thread_create_arch(thread_t *t)
+void thread_create_arch(thread_t *thread)
 {
-        t->arch.tls = 0;
-        t->arch.syscall_rsp[SYSCALL_USTACK_RSP] = 0;
+        thread->arch.tls = 0;
+        thread->arch.syscall_rsp[SYSCALL_USTACK_RSP] = 0;
+        
         /*
          * Kernel RSP can be precalculated at thread creation time.
          */
-        t->arch.syscall_rsp[SYSCALL_KSTACK_RSP] =
-            (uintptr_t) &t->kstack[PAGE_SIZE - sizeof(uint64_t)];
+        thread->arch.syscall_rsp[SYSCALL_KSTACK_RSP] =
+            (uintptr_t) &thread->kstack[PAGE_SIZE - sizeof(istate_t)];
 }
 

kernel/arch/amd64/src/smp/ap.S

@@ -55 +55 @@
         xorw %ax, %ax
         movw %ax, %ds
-
-        lgdtl ap_gdtr           # initialize Global Descriptor Table register
+        
+        lgdtl ap_gdtr       # initialize Global Descriptor Table register
         
         movl %cr0, %eax
         orl $1, %eax
-        movl %eax, %cr0         # switch to protected mode
-        jmpl $gdtselector(KTEXT32_DES), $jump_to_kernel - BOOT_OFFSET + AP_BOOT_OFFSET
-        
+        movl %eax, %cr0     # switch to protected mode
+        jmpl $GDT_SELECTOR(KTEXT32_DES), $jump_to_kernel - BOOT_OFFSET + AP_BOOT_OFFSET
+
 jump_to_kernel:
 .code32
-        movw $gdtselector(KDATA_DES), %ax
+        movw $GDT_SELECTOR(KDATA_DES), %ax
         movw %ax, %ds
         movw %ax, %es
         movw %ax, %ss
-        movw $gdtselector(UDATA_DES), %ax
+        movw $GDT_SELECTOR(UDATA_DES), %ax
         movw %ax, %gs
         
-        # Enable 64-bit page transaltion entries - CR4.PAE = 1.
+        # Enable 64-bit page transaltion entries (CR4.PAE = 1).
         # Paging is not enabled until after long mode is enabled
         
@@ -78 +78 @@
         btsl $5, %eax
         movl %eax, %cr4
-
+        
         leal ptl_0, %eax
         movl %eax, %cr3
         
         # Enable long mode
-        movl $EFER_MSR_NUM, %ecx        # EFER MSR number
-        rdmsr                           # Read EFER
-        btsl $AMD_LME_FLAG, %eax        # Set LME=1
-        wrmsr                           # Write EFER
+        movl $EFER_MSR_NUM, %ecx  # EFER MSR number
+        rdmsr                     # Read EFER
+        btsl $AMD_LME_FLAG, %eax  # Set LME=1
+        wrmsr                     # Write EFER
         
-        # Enable paging to activate long mode (set CR0.PG=1)
+        # Enable paging to activate long mode (set CR0.PG = 1)
         movl %cr0, %eax
         btsl $31, %eax
@@ -94 +94 @@
         
         # At this point we are in compatibility mode
-        jmpl $gdtselector(KTEXT_DES), $start64 - BOOT_OFFSET + AP_BOOT_OFFSET
+        jmpl $GDT_SELECTOR(KTEXT_DES), $start64 - BOOT_OFFSET + AP_BOOT_OFFSET
 
 .code64
 start64:
-        movq (ctx), %rsp
+        movabsq $ctx, %rsp
+        movq (%rsp), %rsp
+        
         pushq $0
         movq %rsp, %rbp
-        call main_ap - AP_BOOT_OFFSET + BOOT_OFFSET   # never returns
+        
+        movabsq $main_ap, %rax
+        callq *%rax   # never returns
 
 #endif /* CONFIG_SMP */

kernel/arch/amd64/src/syscall.c

@@ -58 +58 @@
          */
         write_msr(AMD_MSR_STAR,
-            ((uint64_t)(gdtselector(KDATA_DES) | PL_USER) << 48) |
-            ((uint64_t)(gdtselector(KTEXT_DES) | PL_KERNEL) << 32));
+            ((uint64_t) (GDT_SELECTOR(KDATA_DES) | PL_USER) << 48) |
+            ((uint64_t) (GDT_SELECTOR(KTEXT_DES) | PL_KERNEL) << 32));
         write_msr(AMD_MSR_LSTAR, (uint64_t)syscall_entry);
         /* Mask RFLAGS on syscall 
@@ -66 +66 @@
          * - clear DF so that the string instructions operate in
          *   the right direction
+         * - clear NT to prevent a #GP should the flag proliferate to an IRET
          */
-        write_msr(AMD_MSR_SFMASK, RFLAGS_IF | RFLAGS_DF);
+        write_msr(AMD_MSR_SFMASK, RFLAGS_IF | RFLAGS_DF | RFLAGS_NT);
 }
 

kernel/arch/amd64/src/userspace.c

@@ -36 +36 @@
 #include <arch/cpu.h>
 #include <arch/pm.h>
-#include <arch/types.h>
+#include <typedefs.h>
 #include <arch.h>
 #include <proc/uarg.h>
@@ -65 +65 @@
                 "xorq %%rdi, %%rdi\n"
                 "iretq\n"
-                :: [udata_des] "i" (gdtselector(UDATA_DES) | PL_USER),
+                :: [udata_des] "i" (GDT_SELECTOR(UDATA_DES) | PL_USER),
                    [stack_size] "r" (kernel_uarg->uspace_stack + THREAD_STACK_SIZE),
                    [ipl] "r" (ipl),
-                   [utext_des] "i" (gdtselector(UTEXT_DES) | PL_USER),
+                   [utext_des] "i" (GDT_SELECTOR(UTEXT_DES) | PL_USER),
                    [entry] "r" (kernel_uarg->uspace_entry),
                    [uarg] "r" (kernel_uarg->uspace_uarg)