libbarrelfish: cleanup of code for Xeon Phi
authorReto Achermann <acreto@student.ethz.ch>
Mon, 29 Dec 2014 09:03:24 +0000 (10:03 +0100)
committerReto Achermann <reto.achermann@inf.ethz.ch>
Mon, 12 Jan 2015 16:01:44 +0000 (17:01 +0100)
removed duplicated code in source files for the K1OM architecture
and merged it with the x86_64 code.

Conflicts:
lib/barrelfish/target/k1om/pmap_target.c

lib/barrelfish/Hakefile
lib/barrelfish/arch/k1om/debug.c [deleted file]
lib/barrelfish/arch/k1om/dispatch.c [deleted file]
lib/barrelfish/arch/k1om/entry.S [deleted file]
lib/barrelfish/arch/k1om/ldt.c [deleted file]
lib/barrelfish/arch/k1om/sys_debug.c [deleted file]
lib/barrelfish/arch/k1om/syscalls.c [deleted file]
lib/barrelfish/arch/x86_64/ldt.c
lib/barrelfish/target/k1om/pmap_target.c [deleted file]
lib/barrelfish/vspace/arch/k1om/layout.c [deleted file]

index 015817b..8f94d08 100644 (file)
                                  "vspace/arch/x86_64/layout.c",
                                  "vspace/memobj_pinned.c", "vspace/pinned.c", "vspace/memobj_anon.c",
                                  "arch/x86/perfmon.c", "arch/x86/tls.c"]
-      archfam_srcs "k1om"   = [ "arch/k1om/debug.c", "arch/k1om/dispatch.c" ,
-                                 "arch/k1om/syscalls.c", "arch/k1om/sys_debug.c",
-                                 "arch/k1om/ldt.c",
-                                 "target/k1om/pmap_target.c", "target/x86/pmap_x86.c",
-                                 "vspace/arch/k1om/layout.c",
+      archfam_srcs "k1om"   = [ "arch/x86_64/debug.c", "arch/x86_64/dispatch.c" ,
+                                 "arch/x86_64/syscalls.c", "arch/x86_64/sys_debug.c",
+                                 "arch/x86_64/ldt.c",
+                                 "target/x86_64/pmap_target.c", "target/x86/pmap_x86.c",
+                                 "vspace/arch/x86_64/layout.c",
                                  "vspace/memobj_pinned.c", "vspace/pinned.c", "vspace/memobj_anon.c",
                                  "arch/x86/perfmon.c", "arch/x86/tls.c"]
       archfam_srcs "arm"     = [ "arch/arm/debug.c", "arch/arm/dispatch.c",
@@ -74,7 +74,7 @@
 
       arch_assembly "x86_32"  = [ "arch/x86_32/entry.S" ]
       arch_assembly "x86_64"  = [ "arch/x86_64/entry.S" ]
-      arch_assembly "k1om"  = [ "arch/k1om/entry.S" ]
+      arch_assembly "k1om"    = [ "arch/x86_64/entry.S" ]
       arch_assembly "arm"     = [ "arch/arm/entry.S", "arch/arm/syscall.S" ]
       arch_assembly "armv7-m" = [ "arch/arm/entry.S", "arch/arm/syscall.S" ]
       arch_assembly _         = []
diff --git a/lib/barrelfish/arch/k1om/debug.c b/lib/barrelfish/arch/k1om/debug.c
deleted file mode 100644 (file)
index 1b28ea7..0000000
+++ /dev/null
@@ -1,106 +0,0 @@
-/**
- * \file
- * \brief Arch specific debugging functions
- */
-
-/*
- * Copyright (c) 2010, ETH Zurich.
- * All rights reserved.
- *
- * This file is distributed under the terms in the attached LICENSE file.
- * If you do not find this file, copies can be found by writing to:
- * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
- */
-
-#include <stdio.h>
-#include <barrelfish/barrelfish.h>
-#include <barrelfish/caddr.h>
-#include <barrelfish/debug.h>
-#include <barrelfish/dispatch.h>
-#include <if/monitor_defs.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <string.h>
-#include <inttypes.h>
-
-#define NR_OF_DISPLAYED_RET_ADDRS   10
-
-/**
- * \brief Dump out various memory regions and a partial backtrace.
- *
- * Mainly for debugging traps and faults in the dispatcher handlers.
- */
-void debug_dump(arch_registers_state_t *archregs)
-{
-    struct registers_x86_64 *regs = archregs;
-
-    debug_printf("Dumping stack (0x%lx)...\n", regs->rsp);
-    debug_dump_mem_around_addr(regs->rsp);
-    // debug_printf("Dumping code (0x%lx)...\n", regs->rip);
-    // debug_dump_mem_around_addr(regs->rip);
-    // debug_printf("Dumping memory around rbp (0x%lx)\n", regs->rbp);
-    // debug_dump_mem_around_addr(regs->rbp);
-}
-
-static void debug_call_chain_rbp(uintptr_t bp)
-{
-    uintptr_t ret_addr;
-    uintptr_t user_rbp = bp;
-
-    for (int it = 0; it < NR_OF_DISPLAYED_RET_ADDRS; it++) {
-        if (user_rbp < BASE_PAGE_SIZE || (user_rbp % sizeof(uintptr_t)) != 0) {
-            break;
-        }
-        // get return address
-        ret_addr = *(uintptr_t *)(user_rbp + sizeof(uintptr_t));
-        debug_printf("return address = 0x%" PRIxPTR "\n", ret_addr);
-        // get next RBP
-        user_rbp = *(uintptr_t *)user_rbp;
-    }
-}
-
-void debug_call_chain(arch_registers_state_t *archregs)
-{
-    debug_call_chain_rbp(archregs->rbp);
-}
-
-/**
- * \brief Print out the registers in a dispatcher save area, for trap handlers.
- */
-void debug_print_save_area(arch_registers_state_t *state)
-{
-//#define P(x) debug_printf("%16lx "#x"\n", (uintptr_t)state->x);
-#define P(x) printf("%16lx "#x"\n", (uintptr_t)state->x);
-
-    P(rip);
-    P(rsp);
-    P(rbp);
-    P(rax);
-    P(rbx);
-    P(rcx);
-    P(rdx);
-    P(rdi);
-    P(rsi);
-    P(r8);
-    P(r9);
-    P(r10);
-    P(r11);
-    P(r12);
-    P(r13);
-    P(r14);
-    P(r15);
-    P(eflags);
-    P(fs);
-    P(gs);
-
-#undef P
-}
-
-void debug_return_addresses(void)
-{
-    printf("return address = %p\n", __builtin_return_address(0));
-    printf("return address = %p\n", __builtin_return_address(1));
-    printf("return address = %p\n", __builtin_return_address(2));
-    printf("return address = %p\n", __builtin_return_address(3));
-    printf("return address = %p\n", __builtin_return_address(4));
-}
diff --git a/lib/barrelfish/arch/k1om/dispatch.c b/lib/barrelfish/arch/k1om/dispatch.c
deleted file mode 100644 (file)
index 52a5814..0000000
+++ /dev/null
@@ -1,313 +0,0 @@
-/**
- * \file
- * \brief Dispatcher architecture-specific implementation.
- */
-
-/*
- * Copyright (c) 2007, 2008, 2009, 2010, 2011, 2012, ETH Zurich.
- * All rights reserved.
- *
- * This file is distributed under the terms in the attached LICENSE file.
- * If you do not find this file, copies can be found by writing to:
- * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
- */
-
-#include <barrelfish/barrelfish.h>
-#include <barrelfish/dispatch.h>
-#include <barrelfish/dispatcher_arch.h>
-#include <barrelfish/curdispatcher_arch.h>
-#include <barrelfish/syscalls.h>
-#include "threads_priv.h"
-#include <arch/ldt.h>
-
-/* entry points defined in assembler code */
-extern void run_entry(void);
-extern void pagefault_entry(void);
-extern void disabled_pagefault_entry(void);
-extern void trap_entry(void);
-extern void lrpc_entry(void);
-
-void __attribute__ ((visibility ("hidden"))) disp_resume_end(void);
-
-/**
- * \brief Architecture-specific dispatcher initialisation
- */
-void disp_arch_init(dispatcher_handle_t handle)
-{
-    struct dispatcher_shared_x86_64 *disp =
-        get_dispatcher_shared_x86_64(handle);
-
-    /* Set entry points */
-    disp->d.dispatcher_run = (lvaddr_t)run_entry;
-    disp->d.dispatcher_lrpc = (lvaddr_t)lrpc_entry;
-    disp->d.dispatcher_pagefault = (lvaddr_t)pagefault_entry;
-    disp->d.dispatcher_pagefault_disabled = (lvaddr_t)disabled_pagefault_entry;
-    disp->d.dispatcher_trap = (lvaddr_t)trap_entry;
-
-    disp->crit_pc_low = (lvaddr_t)disp_resume;
-    disp->crit_pc_high = (lvaddr_t)disp_resume_end;
-
-    /* Setup LDT */
-    ldt_init_disabled(handle);
-}
-
-/**
- * \brief Resume execution of a given register state
- *
- * This function resumes the execution of the given register state on the
- * current dispatcher. It may only be called while the dispatcher is disabled.
- *
- * \param disp Current dispatcher pointer
- * \param regs Register state snapshot
- */
-void disp_resume(dispatcher_handle_t handle, arch_registers_state_t *archregs)
-{
-    struct dispatcher_shared_generic *disp =
-        get_dispatcher_shared_generic(handle);
-
-    assert_disabled(disp->disabled);
-    assert_disabled(disp->haswork);
-
-    /* sanity check user state */
-    struct registers_x86_64 *regs = archregs;
-    assert_disabled(regs->rip > BASE_PAGE_SIZE);
-    assert_disabled((regs->eflags & USER_EFLAGS) == USER_EFLAGS); // flags
-
-#ifdef CONFIG_DEBUG_DEADLOCKS
-    ((struct disp_priv *)disp)->yieldcount = 0;
-#endif
-
-    // Re-enable dispatcher
-    disp->disabled = false; // doesn't take effect while we're in disp_resume()
-
-    // Resume program execution
-    __asm volatile ("mov        %[fs], %%ax             \n\t"
-                    "mov        %%ax, %%fs              \n\t"
-                    "mov        %[gs], %%ax             \n\t"
-                    "mov        %%ax, %%gs              \n\t"
-                    "movq        0*8(%[regs]), %%rax    \n\t"
-                    "movq        2*8(%[regs]), %%rcx    \n\t"
-                    "movq        3*8(%[regs]), %%rdx    \n\t"
-                    "movq        4*8(%[regs]), %%rsi    \n\t"
-                    "movq        5*8(%[regs]), %%rdi    \n\t"
-                    "movq        6*8(%[regs]), %%rbp    \n\t"
-                    "movq        8*8(%[regs]), %%r8     \n\t"
-                    "movq        9*8(%[regs]), %%r9     \n\t"
-                    "movq       10*8(%[regs]), %%r10    \n\t"
-                    "movq       11*8(%[regs]), %%r11    \n\t"
-                    "movq       12*8(%[regs]), %%r12    \n\t"
-                    "movq       13*8(%[regs]), %%r13    \n\t"
-                    "movq       14*8(%[regs]), %%r14    \n\t"
-                    "movq       15*8(%[regs]), %%r15    \n\t"
-                    "pushq      %[ss]                   \n\t"   // SS
-                    "pushq       7*8(%[regs])           \n\t"   // RSP
-                    "pushq      17*8(%[regs])           \n\t"   // RFLAGS
-                    "pushq      %[cs]                   \n\t"   // CS
-                    "pushq      16*8(%[regs])           \n\t"   // RIP
-                    "movq        1*8(%[regs]), %%rbx    \n\t"   // RBX was base register
-                    "iretq                              \n\t"
-                    : /* No output */
-                    :
-                    [regs] "b" (regs),
-                    [ss] "i" (USER_SS),
-                    [cs] "i" (USER_CS),
-                    [fs] "m" (regs->fs),
-                    [gs] "m" (regs->gs)
-                    );
-
-    __asm volatile ("disp_resume_end:");
-}
-
-/**
- * \brief Switch execution between two register states, and turn off
- * disabled activations.
- *
- * This function saves as much as necessary of the current register state
- * (which, when resumed will return to the caller), and switches execution
- * by resuming the given register state.  It may only be called while the
- * dispatcher is disabled.  A side effect is that activations are reenabled.
- * Note that the thread context saved is a voluntary save so only callee
- * save registers need to be saved, but we dont currently provide any
- * way to optimise the corresponding resume.
- *
- * \param disp Current dispatcher pointer
- * \param from_regs Location to save current register state
- * \param to_regs Location from which to resume new register state
- */
-// XXX: Needs to be compiled with -O2, otherwise we use too many
-// registers. Have to think about how to circumvent this without needing
-// -O2.
-void
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)
-__attribute__((optimize(2)))
-#endif
-disp_switch(dispatcher_handle_t handle, arch_registers_state_t *from_state,
-            arch_registers_state_t *to_state)
-{
-    struct dispatcher_shared_generic *disp =
-        get_dispatcher_shared_generic(handle);
-    assert_disabled(disp->disabled);
-    assert_disabled(disp->haswork);
-
-    struct dispatcher_generic *disp_gen = get_dispatcher_generic(handle);
-
-    struct registers_x86_64 *from_regs = (struct registers_x86_64*)from_state;
-    struct registers_x86_64 *to_regs   = (struct registers_x86_64*)to_state;
-    assert_disabled(to_regs != NULL);
-
-    // Save resume IP, stack and control registers, ...
-    // then switch stacks to dispatcher, and call resume to switch context
-    // Note the embedded call to disp_resume above.
-    /*
-     * NB: we shouldn't have to save RBP here, rather just list it as clobbered
-     * However, GCC without optimisations uses RBP as a frame pointer and won't
-     * let us do that, so instead we manually save and restore it. This is
-     * usually redundant (without optimisation, GCC saves and restores it; with
-     * optimisation the register is used and thus GCC saves it anyway).
-     */
-    __asm volatile ("movq       %%rbp,  6*8(%[regs])    \n\t"
-                    "movq       %%rsp,  7*8(%[regs])    \n\t"
-                    "lea        switch_resume(%%rip), %%rcx\n\t"
-                    "movq       %%rcx, 16*8(%[regs])    \n\t"   // RIP
-                    "pushfq                             \n\t"
-                    "popq       17*8(%[regs])           \n\t"   // RFLAGS
-                    "mov        %%fs, %%bx              \n\t"
-                    "mov        %%bx, %[fs]             \n\t"
-                    "mov        %%gs, %%bx              \n\t"
-                    "mov        %%bx, %[gs]             \n\t"
-                    "movq       %[stack], %%rsp         \n\t"   // Switch stack
-                    "callq      disp_resume             \n\t"
-                    :
-                    : [regs] "a" (from_regs),
-                      [fs] "m" (from_regs->fs),
-                      [gs] "m" (from_regs->gs),
-                      [stack] "d" ((lvaddr_t)&disp_gen->stack[DISPATCHER_STACK_WORDS]),
-                      [disp] "D" (disp),
-                      [to_regs] "S" (to_regs)
-                    : "rbx", "rcx", "rsp",
-                      "r8", "r9", "r10", "r12", "r13", "r14", "r15"
-                    );
-
-    __asm volatile ("switch_resume:");
-}
-
-/**
- * \brief Save the current register state and optionally yield the CPU
- *
- * This function saves as much as necessary of the current register state
- * (which, when resumed will return to the caller), and then either
- * re-enters the thread scheduler or yields the CPU.
- * It may only be called while the dispatcher is disabled.
- * Note that the thread context saved is a voluntary save so only callee
- * save registers need to be saved, but we dont currently provide any
- * way to optimise the corresponding resume.
- *
- * \param disp Current dispatcher pointer
- * \param regs Location to save current register state
- * \param yield If true, yield CPU to kernel; otherwise re-run thread scheduler
- * \param yield_to Endpoint capability for dispatcher to which we want to yield
- */
-// XXX: Needs to be compiled with -O2, otherwise we use too many
-// registers. Have to think about how to circumvent this without needing
-// -O2.
-void
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)
-__attribute__((optimize(2)))
-#endif
-disp_save(dispatcher_handle_t handle, arch_registers_state_t *state,
-          bool yield, capaddr_t yield_to)
-{
-    struct dispatcher_shared_generic *disp =
-        get_dispatcher_shared_generic(handle);
-    assert_disabled(disp->disabled);
-
-    struct registers_x86_64 *regs = state;
-
-    // Save resume IP, stack and control registers
-    // See disp_switch above for details
-    // XXX: Using the clobber list here to make the compiler save only
-    // used registers. Be very careful when changing the code below
-    // this asm block! If registers in the clobber list are
-    // subsequently used, they won't be restored at save_resume.
-    __asm volatile ("movq       %%rbp,  6*8(%[regs])    \n\t"
-                    "movq       %%rsp,  7*8(%[regs])    \n\t"
-                    "lea        save_resume(%%rip), %%rcx\n\t"
-                    "movq       %%rcx, 16*8(%[regs])    \n\t"   // RIP
-                    "pushfq                             \n\t"
-                    "popq       17*8(%[regs])           \n\t"   // RFLAGS
-                    "mov        %%fs, %%bx              \n\t"
-                    "mov        %%bx, %[fs]             \n\t"
-                    "mov        %%gs, %%bx              \n\t"
-                    "mov        %%bx, %[gs]             \n\t"
-                    :
-                    : [regs] "a" (regs),
-                      [fs] "m" (regs->fs),
-                      [gs] "m" (regs->gs)
-                    : "rbx", "rcx", "rdx", "rsi", "rdi",
-                      "r8", "r9", "r10", "r12", "r13", "r14", "r15"
-                    );
-
-    if (yield) {
-//        trace_event(TRACE_SUBSYS_THREADS, TRACE_EVENT_THREADS_SYS_YIELD, 1);
-
-        sys_yield(yield_to);
-        // may fail if target doesn't exist; if so, just fall through
-    }
-    // this code won't run if the yield succeeded
-
-    // enter thread scheduler again
-    // this doesn't return, and will call disp_yield if there's nothing to do
-    thread_run_disabled(handle);
-
-    __asm volatile ("save_resume:");
-}
-
-void
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)
-__attribute__((optimize(2)))
-#endif
-disp_save_rm_kcb(void)
-{
-    dispatcher_handle_t handle = disp_disable();
-    struct dispatcher_generic *disp_gen = get_dispatcher_generic(handle);
-    struct dispatcher_shared_generic *disp =
-        get_dispatcher_shared_generic(handle);
-    arch_registers_state_t *state =
-        dispatcher_get_enabled_save_area(handle);
-
-    assert_disabled(disp_gen->runq != NULL);
-    assert_disabled(disp->haswork);
-
-    struct registers_x86_64 *regs = state;
-
-    // Save resume IP, stack and control registers
-    // See disp_switch above for details
-    // XXX: Using the clobber list here to make the compiler save only
-    // used registers. Be very careful when changing the code below
-    // this asm block! If registers in the clobber list are
-    // subsequently used, they won't be restored at save_resume.
-    __asm volatile ("movq       %%rbp,  6*8(%[regs])    \n\t"
-                    "movq       %%rsp,  7*8(%[regs])    \n\t"
-                    "lea        save_rm_kcb_resume(%%rip), %%rcx\n\t"
-                    "movq       %%rcx, 16*8(%[regs])    \n\t"   // RIP
-                    "pushfq                             \n\t"
-                    "popq       17*8(%[regs])           \n\t"   // RFLAGS
-                    "mov        %%fs, %%bx              \n\t"
-                    "mov        %%bx, %[fs]             \n\t"
-                    "mov        %%gs, %%bx              \n\t"
-                    "mov        %%bx, %[gs]             \n\t"
-                    :
-                    : [regs] "a" (regs),
-                      [fs] "m" (regs->fs),
-                      [gs] "m" (regs->gs)
-                    : "rbx", "rcx", "rdx", "rsi", "rdi",
-                      "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
-                    );
-
-    // don't halt but remove kcb of this domain
-    sys_suspend(false);
-    //assert_disabled(!"This code won't run if the yield succeeded.");
-
-    __asm volatile ("save_rm_kcb_resume:");
-    // Instead we go here directly
-}
diff --git a/lib/barrelfish/arch/k1om/entry.S b/lib/barrelfish/arch/k1om/entry.S
deleted file mode 100644 (file)
index ecb814c..0000000
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * \file
- * \brief Dispatcher entry points.
- */
-
-/*
- * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
- * All rights reserved.
- *
- * This file is distributed under the terms in the attached LICENSE file.
- * If you do not find this file, copies can be found by writing to:
- * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
- */
-
-#include <barrelfish/dispatch.h>
-#include <asmoffsets.h>
-
-       .text
-       .globl run_entry, pagefault_entry, disabled_pagefault_entry, trap_entry, lrpc_entry
-
-run_entry:
-        // Get dispatcher stack to rsp
-        movq    %rdi, %rsp
-        addq    $(OFFSETOF_DISP_PRIV_STACK_LIMIT), %rsp
-       callq   disp_run        // Handle activation in C
-
-//
-// void pagefault_entry(vaddr_t fault_addr, uintptr_t error, vaddr_t ip)
-//
-pagefault_entry:
-       // Get dispatcher stack
-        movq    %rdi, %rsp
-        addq    $(OFFSETOF_DISP_PRIV_STACK_LIMIT), %rsp
-       callq   disp_pagefault  // handle activation in C
-
-//
-// void disabled_pagefault_entry(vaddr_t fault_addr, uintptr_t error, vaddr_t ip)
-//
-disabled_pagefault_entry:
-       // Get trap stack
-        movq    %rdi, %rsp
-        addq    $(OFFSETOF_DISP_PRIV_TRAP_STACK_LIMIT), %rsp
-       callq   disp_pagefault_disabled // handle activation in C
-
-//
-// void trap_entry(uintptr_t irq, uintptr_t error, vaddr_t ip)
-//
-trap_entry:
-       // Get trap stack
-        movq    %rdi, %rsp
-        addq    $(OFFSETOF_DISP_PRIV_TRAP_STACK_LIMIT), %rsp
-       callq   disp_trap       // handle activation in C
-
-lrpc_entry:
-        /* register state:
-         * rdi = epoffset
-         * esi = bufpos of reserved space in endpoint
-         * rdx, r10, r8, r9 = message body
-         * rax = dispatcher
-         */
-
-        /* shuffle registers to match calling parameters of disp_lrpc */
-        mov     %r10, %rcx
-
-        // Load dispatcher to rsp
-        movq    %rax, %rsp
-
-        // Compute address of endpoint
-        addq    %rsp, %rdi
-        subq    $OFFSETOF_LMP_ENDPOINT_KERNPART, %rdi
-
-        // Load dispatcher stack to rsp
-        addq    $(OFFSETOF_DISP_PRIV_STACK_LIMIT), %rsp
-
-        // Push dispatcher pointer to top of stack (7th function argument)
-        pushq   %rax
-
-        callq   disp_lrpc /* disp_lrpc(ep, bufpos, w1, w2, w3, w4, handle) */
diff --git a/lib/barrelfish/arch/k1om/ldt.c b/lib/barrelfish/arch/k1om/ldt.c
deleted file mode 100644 (file)
index deb9c50..0000000
+++ /dev/null
@@ -1,200 +0,0 @@
-/**
- * \file
- * \brief Local descriptor table (LDT) management
- */
-
-/*
- * Copyright (c) 2011, ETH Zurich.
- * All rights reserved.
- *
- * This file is distributed under the terms in the attached LICENSE file.
- * If you do not find this file, copies can be found by writing to:
- * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
- */
-
-#include <barrelfish/barrelfish.h>
-#include <barrelfish/dispatch.h>
-#include <barrelfish/dispatcher_arch.h>
-#include <barrelfish/curdispatcher_arch.h>
-#include <barrelfish/syscalls.h>
-#include <barrelfish/ldt.h>
-#include <arch/ldt.h>
-#include <target/k1om/barrelfish_kpi/cpu_target.h> // segment_descriptor
-#include <stdio.h>
-
-#define LDT_NENTRIES    512     ///< Number of entries in the statically-sized LDT
-
-/// Local segment descriptor table. Shared by all dispatchers in an address space.
-// (XXX: coherence assumption)
-static union segment_descriptor ldt[LDT_NENTRIES];
-
-/// Spinlock protecting LDT in spanned domains
-// (XXX: coherence assumption)
-static spinlock_t ldt_spinlock;
-
-/** \brief Initialise private (per-dispatcher) LDT */
-void ldt_init_disabled(dispatcher_handle_t handle)
-{
-    errval_t err;
-
-    struct dispatcher_shared_x86_64 *disp =
-        get_dispatcher_shared_x86_64(handle);
-    struct dispatcher_x86_64 *disp_priv = get_dispatcher_x86_64(handle);
-
-    /* setup private (static) LDT, and get kernel to load it */
-    disp->ldt_base = (lvaddr_t) ldt;
-    // XXX: size may not be multiple of page size, but does it really matter?
-    disp->ldt_npages = DIVIDE_ROUND_UP(sizeof(ldt), BASE_PAGE_SIZE);
-    sys_x86_reload_ldt();
-
-    /* XXX: kludge to maintain backwards compatibility.
-     * Setup a single segment descriptor that we can use to locate the
-     * current dispatcher (i.e. curdispatcher() always works). This
-     * will be replaced once we switch onto a thread with a real FS segment.
-     */
-    disp_priv->dummyseg[0] = 0;
-    disp_priv->dummyseg[1] = handle;
-    err = ldt_alloc_segment_disabled(handle, disp_priv->dummyseg,
-                                     &disp_priv->disp_seg_selector);
-    if (err_is_fail(err)) {
-        // XXX: can't call usual debug/panic code, as curdispatcher() won't work
-        char buf[128];
-        snprintf(buf, sizeof(buf),
-                 "%.*s.%u: fatal error in ldt_init_disabled(). Aborted.\n",
-                 DISP_NAME_LEN, disp->d.name, disp_priv->generic.core_id);
-        sys_print(buf, sizeof(buf));
-        while (1) {disp_yield_disabled(handle);}
-    }
-
-    /* load this segment to FS */
-    __asm volatile("mov %%ax, %%fs"
-                   : /* No outputs */
-                   : "a" (disp_priv->disp_seg_selector));
-}
-
-/**
- * \brief Allocate and fill a segment descriptor in the LDT
- *
- * \param handle Dispatcher handle
- * \param segbase Base of segment
- * \param ret_selector On success, used to return selector for new segment
- */
-errval_t ldt_alloc_segment_disabled(dispatcher_handle_t handle, void *segbase,
-                                    uint16_t *ret_selector)
-{
-    // segment descriptors are limited to a 32-bit base address
-    if ((lvaddr_t)segbase >= (1ul << 32)) {
-        return LIB_ERR_SEGBASE_OVER_4G_LIMIT;
-    }
-
-    // construct descriptor
-    union segment_descriptor desc = {
-        .d = {
-            .lo_base = ((lvaddr_t) segbase) & 0xffffff,
-            .hi_base = (((lvaddr_t) segbase) >> 24) & 0xff,
-            .type = 3, /* read/write data, accessed */
-            .system_desc = 1, /* data */
-            .privilege_level = 3, /* user mode */
-            .present = 1,
-            .long_mode = 0,
-            .operation_size = 1,
-        }
-    };
-
-    // find free LDT entry
-    acquire_spinlock(&ldt_spinlock);
-    for (int i = 0; i < LDT_NENTRIES; i++) {
-        if (!ldt[i].d.present) {
-            ldt[i] = desc;
-            release_spinlock(&ldt_spinlock);
-            assert_disabled(ret_selector != NULL);
-            *ret_selector = X86_64_LDT_SELECTOR(i);
-            return SYS_ERR_OK;
-        }
-    }
-    release_spinlock(&ldt_spinlock);
-
-    return LIB_ERR_LDT_FULL;
-}
-
-/**
- * \brief enabled version of ldt_alloc_segment_disabled()
- * 
- * Exposed for calls by special-case software that needs to play with segments.
- */
-errval_t ldt_alloc_segment(void *segbase, uint16_t *ret_selector)
-{
-    dispatcher_handle_t handle = disp_disable();
-    errval_t ret = ldt_alloc_segment_disabled(handle, segbase, ret_selector);
-    disp_enable(handle);
-    return ret;
-}
-
-/**
- * \brief Free a previously-allocated segment on a specific dispatcher
- *
- * \param handle Dispatcher handle
- * \param selector Segment selector
- */
-errval_t ldt_free_segment_ondisp(dispatcher_handle_t handle, uint16_t selector)
-{
-    if ((selector & 0x7) != 7) { // XXX: user-priv LDT selector
-        return LIB_ERR_LDT_SELECTOR_INVALID;
-    }
-
-    int idx = X86_64_SELECTOR_IDX(selector);
-
-    // check that this entry is occupied
-    if (idx >= LDT_NENTRIES || !ldt[idx].d.present) {
-        return LIB_ERR_LDT_SELECTOR_INVALID;
-    }
-
-    // mark entry as free
-    ldt[idx].raw = 0;
-    return SYS_ERR_OK;
-}
-
-/**
- * \brief Free a previously-allocated segment on the current dispatcher
- *
- * \param selector Segment selector
- */
-errval_t ldt_free_segment(uint16_t selector)
-{
-    // strictly speaking, we probably don't need to disable here
-    dispatcher_handle_t handle = disp_disable();
-    errval_t ret = ldt_free_segment_ondisp(handle, selector);
-    disp_enable(handle);
-    return ret;
-}
-
-/**
- * \brief Update the base address of a previously-allocated segment
- *
- * \param selector Segment selector
- * \param segbase New base of segment
- */
-errval_t ldt_update_segment(uint16_t selector, void *segbase)
-{
-    if ((selector & 0x7) != 7) { // XXX: user-priv LDT selector
-        return LIB_ERR_LDT_SELECTOR_INVALID;
-    }
-
-    int idx = X86_64_SELECTOR_IDX(selector);
-
-    // check that this entry is occupied
-    if (idx >= LDT_NENTRIES || !ldt[idx].d.present) {
-        return LIB_ERR_LDT_SELECTOR_INVALID;
-    }
-
-    // segment descriptors are limited to a 32-bit base address
-    if ((lvaddr_t)segbase >= (1ul << 32)) {
-        return LIB_ERR_SEGBASE_OVER_4G_LIMIT;
-    }
-
-    // update base address
-    ldt[idx].d.lo_base = ((lvaddr_t) segbase) & 0xffffff;
-    ldt[idx].d.hi_base = (((lvaddr_t) segbase) >> 24) & 0xff;
-
-    return SYS_ERR_OK;
-}
diff --git a/lib/barrelfish/arch/k1om/sys_debug.c b/lib/barrelfish/arch/k1om/sys_debug.c
deleted file mode 100644 (file)
index acc0e35..0000000
+++ /dev/null
@@ -1,121 +0,0 @@
-/**
- * \file
- * \brief Debug system calls, user-side
- */
-
-/*
- * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
- * All rights reserved.
- *
- * This file is distributed under the terms in the attached LICENSE file.
- * If you do not find this file, copies can be found by writing to:
- * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
- */
-
-#include <barrelfish/barrelfish.h>
-#include <barrelfish/dispatch.h>
-#include <barrelfish/syscall_arch.h>
-#include <barrelfish_kpi/sys_debug.h>
-#include <barrelfish/sys_debug.h>
-#include <stdio.h>
-#include <inttypes.h>
-
-errval_t sys_nop(void)
-{
-    return syscall1(SYSCALL_NOP).error;
-}
-
-errval_t sys_reboot(void)
-{
-    return syscall1(SYSCALL_REBOOT).error;
-}
-
-errval_t sys_debug_context_counter_reset(void)
-{
-    return syscall2(SYSCALL_DEBUG, DEBUG_CONTEXT_COUNTER_RESET).error;
-}
-
-errval_t sys_debug_context_counter_read(uint64_t *ret)
-{
-    struct sysret sr = syscall2(SYSCALL_DEBUG, DEBUG_CONTEXT_COUNTER_READ);
-    *ret = sr.value;
-    return sr.error;
-}
-
-errval_t sys_debug_print_context_counter(void)
-{
-    uint64_t val;
-    errval_t err = sys_debug_context_counter_read(&val);
-    if (err_is_ok(err)) {
-        printf("core %d: csc = %" PRIu64 "\n", disp_get_core_id(), val);
-    }
-    return err;
-}
-
-errval_t sys_debug_timeslice_counter_read(uint64_t *ret)
-{
-    struct sysret sr = syscall2(SYSCALL_DEBUG, DEBUG_TIMESLICE_COUNTER_READ);
-    *ret = sr.value;
-    return sr.error;
-}
-
-errval_t sys_debug_get_tsc_per_ms(uint64_t *ret)
-{
-    struct sysret sr = syscall2(SYSCALL_DEBUG, DEBUG_GET_TSC_PER_MS);
-    *ret = sr.value;
-    return sr.error;
-}
-
-errval_t sys_debug_get_apic_id(uint8_t *ret)
-{
-    struct sysret sr = syscall2(SYSCALL_DEBUG, DEBUG_GET_APIC_ID);
-    *ret = sr.value;
-    return sr.error;
-}
-
-errval_t sys_debug_get_apic_timer(uint32_t *ret)
-{
-    struct sysret sr = syscall2(SYSCALL_DEBUG, DEBUG_GET_APIC_TIMER);
-    *ret = sr.value;
-    return sr.error;
-}
-
-errval_t sys_debug_get_apic_ticks_per_sec(uint32_t *ret)
-{
-    struct sysret sr = syscall2(SYSCALL_DEBUG, DEBUG_GET_APIC_TICKS_PER_SEC);
-    *ret = sr.value;
-    return sr.error;
-}
-
-errval_t sys_debug_print_timeslice(void)
-{
-    uint64_t val;
-    errval_t err = sys_debug_timeslice_counter_read(&val);
-    if (err_is_ok(err)) {
-        printf("core %d: kernel_now = %" PRIu64 "\n", disp_get_core_id(), val);
-    }
-    return err;
-}
-
-errval_t sys_debug_flush_cache(void)
-{
-    return syscall2(SYSCALL_DEBUG, DEBUG_FLUSH_CACHE).error;
-}
-
-errval_t sys_debug_send_ipi(uint8_t destination, uint8_t shorthand, uint8_t vector)
-{
-    return syscall5(SYSCALL_DEBUG,
-                   DEBUG_SEND_IPI, destination, shorthand, vector).error;
-}
-
-errval_t sys_debug_set_breakpoint(uintptr_t addr, uint8_t mode, uint8_t length)
-{
-    return syscall5(SYSCALL_DEBUG,
-                    DEBUG_SET_BREAKPOINT, addr, mode, length).error;
-}
-
-errval_t sys_debug_cap_trace_ctrl(bool enable, genpaddr_t start, gensize_t size)
-{
-    return syscall5(SYSCALL_DEBUG,
-                    DEBUG_TRACE_PMEM_CTRL, enable, start, size).error;
-}
diff --git a/lib/barrelfish/arch/k1om/syscalls.c b/lib/barrelfish/arch/k1om/syscalls.c
deleted file mode 100644 (file)
index 24317a8..0000000
+++ /dev/null
@@ -1,36 +0,0 @@
-/**
- * \file
- * \brief User-side system call implementation
- */
-
-/*
- * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
- * All rights reserved.
- *
- * This file is distributed under the terms in the attached LICENSE file.
- * If you do not find this file, copies can be found by writing to:
- * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
- */
-
-#include <barrelfish/barrelfish.h>
-#include <barrelfish/caddr.h>
-#include <barrelfish/dispatch.h>
-#include <barrelfish/syscall_arch.h>
-
-/* For documentation on system calls see include/barrelfish/syscalls.h
- */
-
-errval_t sys_yield(capaddr_t target)
-{
-    return syscall2(SYSCALL_YIELD, target).error;
-}
-
-errval_t sys_suspend(bool halt)
-{
-    return syscall2(SYSCALL_SUSPEND, halt).error;
-}
-
-errval_t sys_print(const char *string, size_t length)
-{
-    return syscall3(SYSCALL_PRINT, (uintptr_t)string, length).error;
-}
index cda6b41..b31f882 100644 (file)
 #include <barrelfish/syscalls.h>
 #include <barrelfish/ldt.h>
 #include <arch/ldt.h>
+#ifdef __k1om__
+#include <target/k1om/barrelfish_kpi/cpu_target.h> // segment_descriptor
+#else
 #include <target/x86_64/barrelfish_kpi/cpu_target.h> // segment_descriptor
+#endif
 #include <barrelfish_kpi/cpu_arch.h> // segment_descriptor
 #include <stdio.h>
 #include <string.h>
diff --git a/lib/barrelfish/target/k1om/pmap_target.c b/lib/barrelfish/target/k1om/pmap_target.c
deleted file mode 100644 (file)
index 5314608..0000000
+++ /dev/null
@@ -1,904 +0,0 @@
-/**
- * \file
- * \brief pmap management
- *
- * x86_64 specific management of page tables
- *
- * Warning: This code is coupled with the code in slot_alloc/. and pinned.c
- *
- * The maximum number of slots required to map a BASE_PAGE_SIZE
- * sized page is the number of page table levels + 1.
- * The sum for x86_64 is 4.
- *
- * Warning: Additional slots will be required to map a BASE_PAGE_SIZE size page,
- * if we also track the actual frames that are mapped.
- * Currently this is not the case.
- */
-
-/*
- * Copyright (c) 2009, 2010, 2011, ETH Zurich.
- * All rights reserved.
- *
- * This file is distributed under the terms in the attached LICENSE file.
- * If you do not find this file, copies can be found by writing to:
- * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
- */
-
-#include <barrelfish/barrelfish.h>
-#include <barrelfish/dispatch.h>
-#include "target/x86/pmap_x86.h"
-#include <stdio.h>
-
-// Size of virtual region mapped by a single PML4 entry
-#define PML4_MAPPING_SIZE ((genvaddr_t)512*512*512*BASE_PAGE_SIZE)
-
-// Location and size of virtual address space reserved for mapping
-// frames backing refill_slabs
-#define META_DATA_RESERVED_BASE (PML4_MAPPING_SIZE * (disp_get_core_id() + 1))
-#define META_DATA_RESERVED_SIZE (X86_64_BASE_PAGE_SIZE * 20000)
-
-/**
- * \brief Translate generic vregion flags to architecture specific pmap flags
- */
-static paging_x86_64_flags_t vregion_to_pmap_flag(vregion_flags_t vregion_flags)
-{
-    paging_x86_64_flags_t pmap_flags =
-        PTABLE_USER_SUPERVISOR | PTABLE_EXECUTE_DISABLE;
-
-    if (!(vregion_flags & VREGION_FLAGS_GUARD)) {
-        if (vregion_flags & VREGION_FLAGS_WRITE) {
-            pmap_flags |= PTABLE_READ_WRITE;
-        }
-        if (vregion_flags & VREGION_FLAGS_EXECUTE) {
-            pmap_flags &= ~PTABLE_EXECUTE_DISABLE;
-        }
-        if (vregion_flags & VREGION_FLAGS_NOCACHE) {
-            pmap_flags |= PTABLE_CACHE_DISABLED;
-        }
-    }
-
-    return pmap_flags;
-}
-
-static inline bool is_same_pdir(genvaddr_t va1, genvaddr_t va2)
-{
-    return (va1>>X86_64_LARGE_PAGE_BITS) == (va2>>X86_64_LARGE_PAGE_BITS);
-}
-static inline genvaddr_t get_addr_prefix(genvaddr_t va)
-{
-    return va >> X86_64_LARGE_PAGE_BITS;
-}
-static bool has_vnode(struct vnode *root, uint32_t entry, size_t len)
-{
-    assert(root != NULL);
-    assert(root->is_vnode);
-    struct vnode *n;
-
-    uint32_t end_entry = entry + len;
-
-    for (n = root->u.vnode.children; n; n = n->next) {
-        if (n->is_vnode && n->entry == entry) {
-            return true;
-        }
-        // n is frame
-        uint32_t end = n->entry + n->u.frame.pte_count;
-        if (n->entry < entry && end > end_entry) {
-            return true;
-        }
-        if (n->entry >= entry && n->entry < end_entry) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-/**
- * \brief Starting at a given root, return the vnode with starting entry equal to #entry
- */
-static struct vnode *find_vnode(struct vnode *root, uint32_t entry)
-{
-    assert(root != NULL);
-    assert(root->is_vnode);
-    struct vnode *n;
-
-    for(n = root->u.vnode.children; n != NULL; n = n->next) {
-        if(n->entry == entry) {
-            return n;
-        }
-    }
-    return NULL;
-}
-
-static bool inside_region(struct vnode *root, uint32_t entry, uint32_t npages)
-{
-    assert(root != NULL);
-    assert(root->is_vnode);
-
-    struct vnode *n;
-
-    for (n = root->u.vnode.children; n; n = n->next) {
-        if (!n->is_vnode) {
-            uint16_t end = n->entry + n->u.frame.pte_count;
-            if (n->entry <= entry && entry + npages <= end) {
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-static void remove_vnode(struct vnode *root, struct vnode *item)
-{
-    assert(root->is_vnode);
-    struct vnode *walk = root->u.vnode.children;
-    struct vnode *prev = NULL;
-    while (walk) {
-        if (walk == item) {
-            if (prev) {
-                prev->next = walk->next;
-                return;
-            } else {
-                root->u.vnode.children = walk->next;
-                return;
-            }
-        }
-        prev = walk;
-        walk = walk->next;
-    }
-    assert(!"Should not get here");
-}
-
-/**
- * \brief Allocates a new VNode, adding it to the page table and our metadata
- */
-static errval_t alloc_vnode(struct pmap_x86 *pmap, struct vnode *root,
-                            enum objtype type, uint32_t entry,
-                            struct vnode **retvnode)
-{
-    errval_t err;
-
-    struct vnode *newvnode = slab_alloc(&pmap->slab);
-    if (newvnode == NULL) {
-        return LIB_ERR_SLAB_ALLOC_FAIL;
-    }
-
-    // The VNode capability
-    err = pmap->p.slot_alloc->alloc(pmap->p.slot_alloc, &newvnode->u.vnode.cap);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_SLOT_ALLOC);
-    }
-
-    err = vnode_create(newvnode->u.vnode.cap, type);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_VNODE_CREATE);
-    }
-
-    // Map it
-    //printf("\talloc_vnode calling vnode_map()\n");
-    err = vnode_map(root->u.vnode.cap, newvnode->u.vnode.cap, entry,
-                    PTABLE_ACCESS_DEFAULT, 0, 1);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_VNODE_MAP);
-    }
-
-    // The VNode meta data
-    newvnode->is_vnode  = true;
-    newvnode->entry     = entry;
-    newvnode->next      = root->u.vnode.children;
-    root->u.vnode.children = newvnode;
-    newvnode->u.vnode.children = NULL;
-
-    *retvnode = newvnode;
-    return SYS_ERR_OK;
-}
-
-/**
- * \brief Returns the vnode for the pagetable mapping a given vspace address
- */
-static errval_t get_ptable(struct pmap_x86 *pmap, genvaddr_t base,
-                            struct vnode **ptable)
-{
-    errval_t err;
-    struct vnode *root = &pmap->root;
-    struct vnode *pdpt, *pdir;
-    assert(root != NULL);
-
-    // PML4 mapping
-    if((pdpt = find_vnode(root, X86_64_PML4_BASE(base))) == NULL) {
-        err = alloc_vnode(pmap, root, ObjType_VNode_x86_64_pdpt,
-                            X86_64_PML4_BASE(base), &pdpt);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_PMAP_ALLOC_VNODE);
-        }
-    }
-
-    // PDPT mapping
-    if((pdir = find_vnode(pdpt, X86_64_PDPT_BASE(base))) == NULL) {
-        err = alloc_vnode(pmap, pdpt, ObjType_VNode_x86_64_pdir,
-                            X86_64_PDPT_BASE(base), &pdir);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_PMAP_ALLOC_VNODE);
-        }
-    }
-
-    // PDIR mapping
-    if((*ptable = find_vnode(pdir, X86_64_PDIR_BASE(base))) == NULL) {
-        err = alloc_vnode(pmap, pdir, ObjType_VNode_x86_64_ptable,
-                            X86_64_PDIR_BASE(base), ptable);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_PMAP_ALLOC_VNODE);
-        }
-    }
-
-    return SYS_ERR_OK;
-}
-
-
-/**
- * \brief Returns the vnode for the pagetable mapping a given vspace address,
- *     without performing allocations as get_ptable() does
- */
-static struct vnode *find_ptable(struct pmap_x86 *pmap, genvaddr_t base)
-{
-    struct vnode *root = &pmap->root;
-    struct vnode *pdpt, *pdir;
-    assert(root != NULL);
-
-    // PML4 mapping
-    if((pdpt = find_vnode(root, X86_64_PML4_BASE(base))) == NULL) {
-        return NULL;
-    }
-
-    // PDPT mapping
-    if((pdir = find_vnode(pdpt, X86_64_PDPT_BASE(base))) == NULL) {
-        return NULL;
-    }
-
-    // PDIR mapping
-    return find_vnode(pdir, X86_64_PDIR_BASE(base));
-}
-
-static errval_t do_single_map(struct pmap_x86 *pmap, genvaddr_t vaddr, genvaddr_t vend,
-                              struct capref frame, size_t offset, size_t pte_count,
-                              vregion_flags_t flags)
-{
-    // translate flags
-    paging_x86_64_flags_t pmap_flags = vregion_to_pmap_flag(flags);
-
-    // Get the page table
-    struct vnode *ptable;
-    errval_t err = get_ptable(pmap, vaddr, &ptable);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_PMAP_GET_PTABLE);
-    }
-
-    // check if there is an overlapping mapping
-    if (has_vnode(ptable, X86_64_PTABLE_BASE(vaddr), pte_count)) {
-        printf("page already exists in 0x%"PRIxGENVADDR"--0x%"PRIxGENVADDR"\n", vaddr, vend);
-        return LIB_ERR_PMAP_EXISTING_MAPPING;
-    }
-
-    // setup userspace mapping
-    struct vnode *page = slab_alloc(&pmap->slab);
-    assert(page);
-    page->is_vnode = false;
-    page->entry = X86_64_PTABLE_BASE(vaddr);
-    page->next  = ptable->u.vnode.children;
-    ptable->u.vnode.children = page;
-    page->u.frame.cap = frame;
-    page->u.frame.offset = offset;
-    page->u.frame.flags = flags;
-    page->u.frame.pte_count = pte_count;
-
-    // do map
-    err = vnode_map(ptable->u.vnode.cap, frame, X86_64_PTABLE_BASE(vaddr),
-                    pmap_flags, offset, pte_count);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_VNODE_MAP);
-    }
-
-    return SYS_ERR_OK;
-}
-
-/**
- * \brief Called when enough slabs exist for the given mapping
- */
-static errval_t do_map(struct pmap_x86 *pmap, genvaddr_t vaddr,
-                       struct capref frame, size_t offset, size_t size,
-                       vregion_flags_t flags, size_t *retoff, size_t *retsize)
-{
-    errval_t err;
-
-    size = ROUND_UP(size, X86_64_BASE_PAGE_SIZE);
-    size_t pte_count = DIVIDE_ROUND_UP(size, X86_64_BASE_PAGE_SIZE);
-    genvaddr_t vend = vaddr + size;
-
-#if 0
-    struct frame_identity fi;
-    invoke_frame_identify(frame, &fi);
-    genpaddr_t paddr = fi.base + offset;
-
-    debug_printf("do_map: 0x%"
-            PRIxGENVADDR"--0x%"PRIxGENVADDR" -> 0x%"PRIxGENPADDR
-            "; pte_count = %zd; frame bits = %zd\n", vaddr, vend, paddr,
-            pte_count, (size_t)fi.bits);
-#endif
-
-
-    if (is_same_pdir(vaddr, vend)) {
-        // fast path
-        //debug_printf("do_map: fast path: %zd\n", pte_count);
-        err = do_single_map(pmap, vaddr, vend, frame, offset, pte_count, flags);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_PMAP_DO_MAP);
-        }
-    } else { // multiple leaf page tables
-        // first leaf
-        uint32_t c = X86_64_PTABLE_SIZE - X86_64_PTABLE_BASE(vaddr);
-        //debug_printf("do_map: slow path: first leaf %"PRIu32"\n", c);
-        genvaddr_t temp_end = vaddr + c * X86_64_BASE_PAGE_SIZE;
-        err = do_single_map(pmap, vaddr, temp_end, frame, offset, c, flags);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_PMAP_DO_MAP);
-        }
-
-        // map full leaves
-        while (get_addr_prefix(temp_end) < get_addr_prefix(vend)) {
-            // update vars
-            vaddr = temp_end;
-            temp_end = vaddr + X86_64_PTABLE_SIZE * X86_64_BASE_PAGE_SIZE;
-            offset += c * X86_64_BASE_PAGE_SIZE;
-            c = X86_64_PTABLE_SIZE;
-            // copy cap
-            struct capref next;
-            err = slot_alloc(&next);
-            if (err_is_fail(err)) {
-                return err_push(err, LIB_ERR_PMAP_DO_MAP);
-            }
-            err = cap_copy(next, frame);
-            if (err_is_fail(err)) {
-                return err_push(err, LIB_ERR_PMAP_DO_MAP);
-            }
-            frame = next;
-
-            // do mapping
-            //debug_printf("do_map: slow path: full leaf %d\n", X86_64_PTABLE_SIZE);
-            err = do_single_map(pmap, vaddr, temp_end, frame, offset, X86_64_PTABLE_SIZE, flags);
-            if (err_is_fail(err)) {
-                return err_push(err, LIB_ERR_PMAP_DO_MAP);
-            }
-        }
-
-        // map remaining part
-        offset += c * X86_64_BASE_PAGE_SIZE;
-        c = X86_64_PTABLE_BASE(vend) - X86_64_PTABLE_BASE(temp_end);
-        if (c) {
-            // copy cap
-            struct capref next;
-            err = slot_alloc(&next);
-            if (err_is_fail(err)) {
-                return err_push(err, LIB_ERR_PMAP_DO_MAP);
-            }
-            err = cap_copy(next, frame);
-            if (err_is_fail(err)) {
-                return err_push(err, LIB_ERR_PMAP_DO_MAP);
-            }
-
-            // do mapping
-            //debug_printf("do_map: slow path: last leaf %"PRIu32"\n", c);
-            err = do_single_map(pmap, temp_end, vend, next, offset, c, flags);
-            if (err_is_fail(err)) {
-                return err_push(err, LIB_ERR_PMAP_DO_MAP);
-            }
-        }
-    }
-
-    if (retoff) {
-        *retoff = offset;
-    }
-    if (retsize) {
-        *retsize = size;
-    }
-    return SYS_ERR_OK;
-}
-
-/// Computer upper limit on number of slabs required to perform a mapping
-static size_t max_slabs_for_mapping(size_t bytes)
-{
-    size_t max_pages  = DIVIDE_ROUND_UP(bytes, X86_64_BASE_PAGE_SIZE);
-    size_t max_ptable = DIVIDE_ROUND_UP(max_pages, X86_64_PTABLE_SIZE);
-    size_t max_pdir   = DIVIDE_ROUND_UP(max_ptable, X86_64_PTABLE_SIZE);
-    size_t max_pdpt   = DIVIDE_ROUND_UP(max_pdir, X86_64_PTABLE_SIZE);
-    return max_pages + max_ptable + max_pdir + max_pdpt;
-}
-
-/**
- * \brief Refill slabs used for metadata
- *
- * \param pmap     The pmap to refill in
- * \param request  The number of slabs the allocator must have
- * when the function returns
- *
- * When the current pmap is initialized,
- * it reserves some virtual address space for metadata.
- * This reserved address space is used here
- *
- * Can only be called for the current pmap
- * Will recursively call into itself till it has enough slabs
- */
-static errval_t refill_slabs(struct pmap_x86 *pmap, size_t request)
-{
-    errval_t err;
-
-    /* Keep looping till we have #request slabs */
-    while (slab_freecount(&pmap->slab) < request) {
-        // Amount of bytes required for #request
-        size_t bytes = SLAB_STATIC_SIZE(request - slab_freecount(&pmap->slab),
-                                        sizeof(struct vnode));
-
-        /* Get a frame of that size */
-        struct capref cap;
-        err = frame_alloc(&cap, bytes, &bytes);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_FRAME_ALLOC);
-        }
-
-        /* If we do not have enough slabs to map the frame in, recurse */
-        size_t required_slabs_for_frame = max_slabs_for_mapping(bytes);
-        if (slab_freecount(&pmap->slab) < required_slabs_for_frame) {
-            // If we recurse, we require more slabs than to map a single page
-            assert(required_slabs_for_frame > 4);
-
-            err = refill_slabs(pmap, required_slabs_for_frame);
-            if (err_is_fail(err)) {
-                return err_push(err, LIB_ERR_SLAB_REFILL);
-            }
-        }
-
-        /* Perform mapping */
-        genvaddr_t genvaddr = pmap->vregion_offset;
-        pmap->vregion_offset += (genvaddr_t)bytes;
-        assert(pmap->vregion_offset < vregion_get_base_addr(&pmap->vregion) +
-               vregion_get_size(&pmap->vregion));
-
-        err = do_map(pmap, genvaddr, cap, 0, bytes,
-                     VREGION_FLAGS_READ_WRITE, NULL, NULL);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_PMAP_DO_MAP);
-        }
-
-        /* Grow the slab */
-        lvaddr_t buf = vspace_genvaddr_to_lvaddr(genvaddr);
-        slab_grow(&pmap->slab, (void*)buf, bytes);        
-    }
-
-    return SYS_ERR_OK;
-}
-
-/// Minimally refill the slab allocator
-static errval_t min_refill_slabs(struct pmap_x86 *pmap)
-{
-    return refill_slabs(pmap, 5);
-}
-
-/**
- * \brief Create page mappings
- *
- * \param pmap     The pmap object
- * \param vaddr    The virtual address to create the mapping for
- * \param frame    The frame cap to map in
- * \param offset   Offset into the frame cap
- * \param size     Size of the mapping
- * \param flags    Flags for the mapping
- * \param retoff   If non-NULL, filled in with adjusted offset of mapped region
- * \param retsize  If non-NULL, filled in with adjusted size of mapped region
- */
-static errval_t map(struct pmap *pmap, genvaddr_t vaddr, struct capref frame,
-                    size_t offset, size_t size, vregion_flags_t flags,
-                    size_t *retoff, size_t *retsize)
-{
-    errval_t err;
-    struct pmap_x86 *x86 = (struct pmap_x86*)pmap;
-
-    // Adjust the parameters to page boundaries
-    size   += BASE_PAGE_OFFSET(offset);
-    size    = ROUND_UP(size, BASE_PAGE_SIZE);
-    offset -= BASE_PAGE_OFFSET(offset);
-
-    // Refill slab allocator if necessary
-    size_t slabs_free = slab_freecount(&x86->slab);
-    size_t max_slabs = max_slabs_for_mapping(size);
-    max_slabs += 5; // minimum amount required to map a page
-    if (slabs_free < max_slabs) { 
-        struct pmap *mypmap = get_current_pmap();
-        if (pmap == mypmap) {
-            err = refill_slabs(x86, max_slabs);
-            if (err_is_fail(err)) {
-                return err_push(err, LIB_ERR_SLAB_REFILL);
-            }
-        } else {
-            size_t bytes = SLAB_STATIC_SIZE(max_slabs - slabs_free,
-                                            sizeof(struct vnode));
-            void *buf = malloc(bytes);
-            if (!buf) {
-                return LIB_ERR_MALLOC_FAIL;
-            }
-            slab_grow(&x86->slab, buf, bytes);
-        }
-    }
-
-    err = do_map(x86, vaddr, frame, offset, size, flags, retoff, retsize);
-    return err;
-}
-
-static errval_t do_single_unmap(struct pmap_x86 *pmap, genvaddr_t vaddr, size_t pte_count, bool delete_cap)
-{
-    errval_t err;
-    struct vnode *pt = find_ptable(pmap, vaddr);
-    if (pt) {
-        struct vnode *page = find_vnode(pt, X86_64_PTABLE_BASE(vaddr));
-        if (page && page->u.frame.pte_count == pte_count) {
-            err = vnode_unmap(pt->u.vnode.cap, page->u.frame.cap, page->entry, page->u.frame.pte_count);
-            if (err_is_fail(err)) {
-                printf("vnode_unmap returned error: %s (%d)\n", err_getstring(err), err_no(err));
-                return err_push(err, LIB_ERR_VNODE_UNMAP);
-            }
-
-            // Free up the resources
-            if (delete_cap) {
-                err = cap_destroy(page->u.frame.cap);
-                if (err_is_fail(err)) {
-                    return err_push(err, LIB_ERR_PMAP_DO_SINGLE_UNMAP);
-                }
-            }
-            remove_vnode(pt, page);
-            slab_free(&pmap->slab, page);
-        }
-        else {
-            return LIB_ERR_PMAP_FIND_VNODE;
-        }
-    }
-
-    return SYS_ERR_OK;
-}
-
-/**
- * \brief Remove page mappings
- *
- * \param pmap     The pmap object
- * \param vaddr    The start of the virtual addres to remove
- * \param size     The size of virtual address to remove
- * \param retsize  If non-NULL, filled in with the actual size removed
- */
-static errval_t unmap(struct pmap *pmap, genvaddr_t vaddr, size_t size,
-                      size_t *retsize)
-{
-    //printf("[unmap] 0x%"PRIxGENVADDR", %zu\n", vaddr, size);
-    errval_t err, ret = SYS_ERR_OK;
-    struct pmap_x86 *x86 = (struct pmap_x86*)pmap;
-    size = ROUND_UP(size, X86_64_BASE_PAGE_SIZE);
-    genvaddr_t vend = vaddr + size;
-
-    if (is_same_pdir(vaddr, vend)) {
-        // fast path
-        err = do_single_unmap(x86, vaddr, size / X86_64_BASE_PAGE_SIZE, false);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_PMAP_UNMAP);
-        }
-    }
-    else { // slow path
-        // unmap first leaf
-        uint32_t c = X86_64_PTABLE_SIZE - X86_64_PTABLE_BASE(vaddr);
-        err = do_single_unmap(x86, vaddr, c, false);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_PMAP_UNMAP);
-        }
-
-        // unmap full leaves
-        vaddr += c * X86_64_BASE_PAGE_SIZE;
-        while (get_addr_prefix(vaddr) < get_addr_prefix(vend)) {
-            c = X86_64_PTABLE_SIZE;
-            err = do_single_unmap(x86, vaddr, X86_64_PTABLE_SIZE, true);
-            if (err_is_fail(err)) {
-                return err_push(err, LIB_ERR_PMAP_UNMAP);
-            }
-            vaddr += c * X86_64_BASE_PAGE_SIZE;
-        }
-
-        // unmap remaining part
-        c = X86_64_PTABLE_BASE(vend) - X86_64_PTABLE_BASE(vaddr);
-        if (c) {
-            err = do_single_unmap(x86, vaddr, c, true);
-            if (err_is_fail(err)) {
-                return err_push(err, LIB_ERR_PMAP_UNMAP);
-            }
-        }
-    }
-
-    if (retsize) {
-        *retsize = size;
-    }
-
-    //printf("[unmap] exiting\n");
-    return ret;
-}
-
-static errval_t do_single_modify_flags(struct pmap_x86 *pmap, genvaddr_t vaddr,
-                                       size_t pages, vregion_flags_t flags)
-{
-    errval_t err = SYS_ERR_OK;
-    struct vnode *ptable = find_ptable(pmap, vaddr);
-    uint16_t ptentry = X86_64_PTABLE_BASE(vaddr);
-    if (ptable) {
-        struct vnode *page = find_vnode(ptable, ptentry);
-        if (page) {
-            if (inside_region(ptable, ptentry, pages)) {
-                // we're modifying part of a valid mapped region
-                // arguments to invocation: invoke frame cap, first affected
-                // page (as offset from first page in mapping), #affected
-                // pages, new flags. Invocation should check compatibility of
-                // new set of flags with cap permissions.
-                size_t off = ptentry - page->entry;
-                paging_x86_64_flags_t pmap_flags = vregion_to_pmap_flag(flags);
-                err = invoke_frame_modify_flags(page->u.frame.cap, off, pages, pmap_flags);
-                printf("invoke_frame_modify_flags returned error: %s (%"PRIuERRV")\n",
-                        err_getstring(err), err);
-                return err;
-            } else {
-                // overlaps some region border
-                return LIB_ERR_PMAP_EXISTING_MAPPING;
-            }
-        }
-    }
-    return SYS_ERR_OK;
-}
-
-
-/**
- * \brief Modify page mapping
- *
- * \param pmap     The pmap object
- * \param vaddr    The virtual address to unmap
- * \param flags    New flags for the mapping
- * \param retsize  If non-NULL, filled in with the actual size modified
- */
-static errval_t modify_flags(struct pmap *pmap, genvaddr_t vaddr, size_t size,
-                             vregion_flags_t flags, size_t *retsize)
-{
-    errval_t err;
-    struct pmap_x86 *x86 = (struct pmap_x86 *)pmap;
-    size = ROUND_UP(size, X86_64_BASE_PAGE_SIZE);
-    size_t pages = size / X86_64_BASE_PAGE_SIZE;
-    genvaddr_t vend = vaddr + size;
-
-    // vaddr and vend specify begin and end of the region (inside a mapping)
-    // that should receive the new set of flags
-
-    if (is_same_pdir(vaddr, vend)) {
-        // fast path
-        err = do_single_modify_flags(x86, vaddr, pages, flags);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_PMAP_MODIFY_FLAGS);
-        }
-    }
-    else { // slow path
-        // modify first part
-        uint32_t c = X86_64_PTABLE_SIZE - X86_64_PTABLE_BASE(vaddr);
-        err = do_single_modify_flags(x86, vaddr, c, flags);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_PMAP_MODIFY_FLAGS);
-        }
-
-        // modify full leaves
-        vaddr += c * X86_64_BASE_PAGE_SIZE;
-        while (get_addr_prefix(vaddr) < get_addr_prefix(vend)) {
-            c = X86_64_PTABLE_SIZE;
-            err = do_single_modify_flags(x86, vaddr, X86_64_PTABLE_SIZE, flags);
-            if (err_is_fail(err)) {
-                return err_push(err, LIB_ERR_PMAP_MODIFY_FLAGS);
-            }
-            vaddr += c * X86_64_BASE_PAGE_SIZE;
-        }
-
-        // modify remaining part
-        c = X86_64_PTABLE_BASE(vend) - X86_64_PTABLE_BASE(vaddr);
-        if (c) {
-            err = do_single_modify_flags(x86, vaddr, c, flags);
-            if (err_is_fail(err)) {
-                return err_push(err, LIB_ERR_PMAP_MODIFY_FLAGS);
-            }
-        }
-    }
-
-    if (retsize) {
-        *retsize = size;
-    }
-
-    //printf("[modify_flags] exiting\n");
-    return SYS_ERR_OK;
-}
-
-/**
- * \brief Query existing page mapping
- *
- * \param pmap     The pmap object
- * \param vaddr    The virtual address to query
- * \param retvaddr Returns the base virtual address of the mapping
- * \param retsize  Returns the actual size of the mapping
- * \param retcap   Returns the cap mapped at this address
- * \param retoffset Returns the offset within the cap that is mapped
- * \param retflags Returns the flags for this mapping
- *
- * All of the ret parameters are optional.
- */
-static errval_t lookup(struct pmap *pmap, genvaddr_t vaddr,
-                       genvaddr_t *retvaddr, size_t *retsize,
-                       struct capref *retcap, genvaddr_t *retoffset,
-                       vregion_flags_t *retflags)
-{
-    struct pmap_x86 *x86 = (struct pmap_x86 *)pmap;
-
-    // Find the page table
-    struct vnode *ptable = find_ptable(x86, vaddr);
-    if (ptable == NULL) {
-        return LIB_ERR_PMAP_FIND_VNODE;
-    }
-
-    // Find the page
-    struct vnode *vn = find_vnode(ptable, X86_64_PTABLE_BASE(vaddr));
-    if (vn == NULL) {
-        return LIB_ERR_PMAP_FIND_VNODE;
-    }
-
-    if (retvaddr) {
-        *retvaddr = vaddr & ~(genvaddr_t)BASE_PAGE_MASK;
-    }
-
-    if (retsize) {
-        *retsize = BASE_PAGE_SIZE;
-    }
-
-    if (retcap) {
-        *retcap = vn->u.frame.cap;
-    }
-
-    if (retoffset) {
-        *retoffset = vn->u.frame.offset;
-    }
-
-    if (retflags) {
-        *retflags = vn->u.frame.flags;
-    }
-
-    return SYS_ERR_OK;
-}
-
-static errval_t dump(struct pmap *pmap, struct pmap_dump_info *buf, size_t buflen, size_t *items_written)
-{
-    struct pmap_x86 *x86 = (struct pmap_x86 *)pmap;
-    struct pmap_dump_info *buf_ = buf;
-
-    struct vnode *pml4 = &x86->root;
-    struct vnode *pdpt, *pdir, *pt, *frame;
-    assert(pml4 != NULL);
-
-    *items_written = 0;
-
-    // iterate over PML4 entries
-    size_t pml4_index, pdpt_index, pdir_index;
-    for (pdpt = pml4->u.vnode.children; pdpt != NULL; pdpt = pdpt->next) {
-        pml4_index = pdpt->entry;
-        // iterate over pdpt entries
-        for (pdir = pdpt->u.vnode.children; pdir != NULL; pdir = pdir->next) {
-            pdpt_index = pdir->entry;
-            // iterate over pdir entries
-            for (pt = pdir->u.vnode.children; pt != NULL; pt = pt->next) {
-                pdir_index = pt->entry;
-                // iterate over pt entries
-                for (frame = pt->u.vnode.children; frame != NULL; frame = frame->next) {
-                    if (*items_written < buflen) {
-                        buf_->pml4_index = pml4_index;
-                        buf_->pdpt_index = pdpt_index;
-                        buf_->pdir_index = pdir_index;
-                        buf_->pt_index = frame->entry;
-                        buf_->cap = frame->u.frame.cap;
-                        buf_->offset = frame->u.frame.offset;
-                        buf_->flags = frame->u.frame.flags;
-                        buf_++;
-                        (*items_written)++;
-                    }
-                }
-            }
-        }
-    }
-    return SYS_ERR_OK;
-}
-
-static struct pmap_funcs pmap_funcs = {
-    .determine_addr = pmap_x86_determine_addr,
-    .map = map,
-    .unmap = unmap,
-    .lookup = lookup,
-    .modify_flags = modify_flags,
-    .serialise = pmap_x86_serialise,
-    .deserialise = pmap_x86_deserialise,
-    .dump = dump,
-};
-
-/**
- * \brief Initialize a x86 pmap object
- *
- * \param pmap Pmap object of type x86
- */
-errval_t pmap_x86_64_init(struct pmap *pmap, struct vspace *vspace,
-                          struct capref vnode,
-                          struct slot_allocator *opt_slot_alloc)
-{
-    struct pmap_x86 *x86 = (struct pmap_x86*)pmap;
-
-    /* Generic portion */
-    pmap->f = pmap_funcs;
-    pmap->vspace = vspace;
-
-    if (opt_slot_alloc != NULL) {
-        pmap->slot_alloc = opt_slot_alloc;
-    } else { /* use default allocator for this dispatcher */
-        pmap->slot_alloc = get_default_slot_allocator();
-    }
-
-    /* x86 specific portion */
-    slab_init(&x86->slab, sizeof(struct vnode), NULL);
-    slab_grow(&x86->slab, x86->slab_buffer,
-              sizeof(x86->slab_buffer));
-    x86->refill_slabs = min_refill_slabs;
-
-    x86->root.is_vnode          = true;
-    x86->root.u.vnode.cap       = vnode;
-    x86->root.u.vnode.children  = NULL;
-    x86->root.next              = NULL;
-
-    // choose a minimum mappable VA for most domains; enough to catch NULL
-    // pointer derefs with suitably large offsets
-    x86->min_mappable_va = 64 * 1024;
-
-    // maximum mappable VA is drived from X86_64_MEMORY_OFFSET in kernel
-    x86->max_mappable_va = (genvaddr_t)0xffffff8000000000;
-
-    return SYS_ERR_OK;
-}
-
-/**
- * \brief Initialize the current pmap. Reserve space for metadata
- *
- * This code is coupled with #vspace_current_init()
- */
-errval_t pmap_x86_64_current_init(bool init_domain)
-{
-    struct pmap_x86 *x86 = (struct pmap_x86*)get_current_pmap();
-
-    // To reserve a block of virtual address space,
-    // a vregion representing the address space is required.
-    // We construct a superficial one here and add it to the vregion list.
-    struct vregion *vregion = &x86->vregion;
-    vregion->vspace = NULL;
-    vregion->memobj = NULL;
-    vregion->base   = META_DATA_RESERVED_BASE;
-    vregion->offset = 0;
-    vregion->size   = META_DATA_RESERVED_SIZE;
-    vregion->flags  = 0;
-    vregion->next = NULL;
-
-    struct vspace *vspace = x86->p.vspace;
-    assert(!vspace->head);
-    vspace->head = vregion;
-
-    x86->vregion_offset = x86->vregion.base;
-
-    // We don't know the vnode layout for the first part of our address space
-    // (which was setup by the kernel), so we avoid mapping there until told it.
-    x86->min_mappable_va = META_DATA_RESERVED_BASE;
-
-    return SYS_ERR_OK;
-}
diff --git a/lib/barrelfish/vspace/arch/k1om/layout.c b/lib/barrelfish/vspace/arch/k1om/layout.c
deleted file mode 100644 (file)
index e9044ac..0000000
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
- * \file
- * \brief
- *
- * \bug Move into different directories
- */
-
-/*
- * Copyright (c) 2010, ETH Zurich.
- * All rights reserved.
- *
- * This file is distributed under the terms in the attached LICENSE file.
- * If you do not find this file, copies can be found by writing to:
- * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
- */
-
-#include <barrelfish/barrelfish.h>
-#include "../../vspace_internal.h"
-
-/**
- * \brief Initialize the x86_64 layout
- */
-errval_t vspace_layout_init(struct vspace_layout *l)
-{
-    l->offset = 0;
-    l->granularity = X86_64_BASE_PAGE_SIZE;
-    l->size = (genvaddr_t)X86_64_PTABLE_SIZE * X86_64_PTABLE_SIZE *
-               X86_64_PTABLE_SIZE * X86_64_PTABLE_SIZE * X86_64_BASE_PAGE_SIZE;
-
-    return SYS_ERR_OK;
-}