mereged changes to elf_object.cc

base/loader/elf_object.cc:
    merged changes to elf_object.cc

--HG--
extra : convert_revision : 2b7a6083d45f0221646e2ebe5b91ee45ec8c6b7c

9 files changed, 1663 insertions, 8 deletions

diff --git a/arch/alpha/alpha_memory.cc b/arch/alpha/alpha_memory.cc
index d934299b8..84b3d5840 100644
--- a/arch/alpha/alpha_memory.cc
+++ b/arch/alpha/alpha_memory.cc
@@ -90,8 +90,16 @@ AlphaTlb::checkCacheability(MemReqPtr req)
     if (req->paddr & PA_UNCACHED_BIT) {
         if (PA_IPR_SPACE(req->paddr)) {
             // IPR memory space not implemented
-            if (!req->xc->misspeculating())
-                panic("IPR memory space not implemented! PA=%x\n", req->paddr);
+            if (!req->xc->misspeculating()) {
+                switch (req->paddr) {
+                  case 0xFFFFF00188:
+                    req->data = 0;
+                    break;
+
+                  default:
+                    panic("IPR memory space not implemented! PA=%x\n", req->paddr);
+                }
+            }
         } else {
             // mark request as uncacheable
             req->flags |= UNCACHEABLE;
diff --git a/base/loader/elf_object.cc b/base/loader/elf_object.cc
index 93313fac6..929d455a5 100644
--- a/base/loader/elf_object.cc
+++ b/base/loader/elf_object.cc
@@ -186,7 +186,7 @@ bool
 ElfObject::loadSomeSymbols(SymbolTable *symtab, int binding)
 {
     Elf *elf;
-    int secidx = 1; // there is a 0 but it is nothing, go figure
+    int sec_idx = 1; // there is a 0 but it is nothing, go figure
     Elf_Scn *section;
     GElf_Shdr shdr;
     Elf_Data *data;
@@ -206,7 +206,7 @@ ElfObject::loadSomeSymbols(SymbolTable *symtab, int binding)
     assert(elf != NULL);
 
     // Get the first section
-    section = elf_getscn(elf, secidx);
+    section = elf_getscn(elf, sec_idx);
 
     // While there are no more sections
     while (section != NULL) {
@@ -227,8 +227,8 @@ ElfObject::loadSomeSymbols(SymbolTable *symtab, int binding)
                 }
             }
         }
-        ++secidx;
-        section = elf_getscn(elf, secidx);
+        ++sec_idx;
+        section = elf_getscn(elf, sec_idx);
     }
 
     elf_end(elf);
diff --git a/cpu/exetrace.cc b/cpu/exetrace.cc
index 3e8877e93..a72242232 100644
--- a/cpu/exetrace.cc
+++ b/cpu/exetrace.cc
@@ -48,11 +48,12 @@ using namespace std;
 //
 
 
-const SymbolTable *debugSymbolTable = NULL;
+SymbolTable *debugSymbolTable = NULL;
 
 void
 Trace::InstRecord::dump(ostream &outs)
 {
+
     if (flags[PRINT_CYCLE])
         ccprintf(outs, "%7d: ", cycle);
 
@@ -64,7 +65,12 @@ Trace::InstRecord::dump(ostream &outs)
     if (flags[PRINT_THREAD_NUM])
         outs << "T" << thread << " : ";
 
-    outs << "0x" << hex << PC << " : ";
+
+    std::string str;
+    if(debugSymbolTable->findSymbol(data.as_int, str))
+        outs << "@" << setw(17) << str << " : ";
+    else
+        outs << "0x" << hex << PC << " : ";
 
     //
     //  Print decoded instruction
diff --git a/dev/alpha_access.h b/dev/alpha_access.h
index 7502635e9..20c8afd30 100644
--- a/dev/alpha_access.h
+++ b/dev/alpha_access.h
@@ -39,6 +39,8 @@
 #include <ostream>
 #include <string>
 class Checkpoint;
+#else
+#include <inttypes.h>
 #endif
 
 // This structure hacked up from simos
diff --git a/kern/linux/linux.hh b/kern/linux/linux.hh
new file mode 100644
index 000000000..a3cb94e91
--- /dev/null
+++ b/kern/linux/linux.hh
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2003 The Regents of The University of Michigan
+ * 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;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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 COPYRIGHT
+ * OWNER OR CONTRIBUTORS 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.
+ */
+
+#ifndef __LINUX_HH__
+#define __LINUX_HH__
+
+class Linux {};
+
+#endif // __LINUX_HH__
diff --git a/kern/linux/linux_syscalls.cc b/kern/linux/linux_syscalls.cc
new file mode 100644
index 000000000..d259499a2
--- /dev/null
+++ b/kern/linux/linux_syscalls.cc
@@ -0,0 +1,376 @@
+/*
+ * Copyright (c) 2003 The Regents of The University of Michigan
+ * 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;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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 COPYRIGHT
+ * OWNER OR CONTRIBUTORS 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 "kern/linux/linux_syscalls.hh"
+
+namespace {
+    const char *
+    standard_strings[SystemCalls<Linux>::StandardNumber] = {
+
+
+     "llseek",		 //0
+     "newselect",		 //1
+     "sysctl",		 //2
+     "access",		 //3
+     "acct",		 //4
+     "adjtimex",		 //5
+     "afs_syscall",		 //6
+     "alarm",		 //7
+     "bdflush",		 //8
+     "break",		 //9
+
+
+     "brk",		 //10
+     "capget",		 //11
+     "capset",		 //12
+     "chdir",		 //13
+     "chmod",		 //14
+     "chown",		 //15
+     "chown32",		 //16
+     "chroot",		 //17
+     "clock_getres",		 //18
+     "clock_gettime",		 //19
+
+
+     "clock_nanosleep",		 //20
+     "clock_settime",		 //21
+     "clone",		 //22
+     "close",		 //23
+     "creat",		 //24
+     "create_module",		 //25
+     "delete_module",		 //26
+     "dup",		 //27
+     "dup2",		 //28
+     "epoll_create",		 //29
+
+
+     "epoll_ctl",		 //30
+     "epoll_wait",		 //31
+     "execve",		 //32
+     "exit",		 //33
+     "exit_group",		 //34
+     "fadvise64",		 //35
+     "fadvise64_64",		 //36
+     "fchdir",		 //37
+     "fchmod",		 //38
+     "fchown",		 //39
+
+
+     "fchown32",		 //40
+     "fcntl",		 //41
+     "fcntl64",		 //42
+     "fdatasync",		 //43
+     "fgetxattr",		 //44
+     "flistxattr",		 //45
+     "flock",		 //46
+     "fork",		 //47
+     "fremovexattr",		 //48
+     "fsetxattr",		 //49
+
+
+     "fstat",		 //50
+     "fstat64",		 //51
+     "fstatfs",		 //52
+     "fstatfs64",		 //53
+     "fsync",		 //54
+     "ftime",		 //55
+     "ftruncate",		 //56
+     "ftruncate64",		 //57
+     "futex",		 //58
+     "get_kernel_syms",		 //59
+
+
+     "get_thread_area",		 //60
+     "getcwd",		 //61
+     "getdents",		 //62
+     "getdents64",		 //63
+     "getegid",		 //64
+     "getegid32",		 //65
+     "geteuid",		 //66
+     "geteuid32",		 //67
+     "getgid",		 //68
+     "getgid32",		 //69
+
+
+     "getgroups",		 //70
+     "getgroups32",		 //71
+     "getitimer",		 //72
+     "getpgid",		 //73
+     "getpgrp",		 //74
+     "getpid",		 //75
+     "getpmsg",		 //76
+     "getppid",		 //77
+     "getpriority",		 //78
+     "getresgid",		 //79
+
+
+     "getresgid32",		 //80
+     "getresuid",		 //81
+     "getresuid32",		 //82
+     "getrlimit",		 //83
+     "getrusage",		 //84
+     "getsid",		 //85
+     "gettid",		 //86
+     "gettimeofday",		 //87
+     "getuid",		 //88
+     "getuid32",		 //89
+
+
+     "getxattr",		 //90
+     "gtty",		 //91
+     "idle",		 //92
+     "init_module",		 //93
+     "io_cancel",		 //94
+     "io_destroy",		 //95
+     "io_getevents",		 //96
+     "io_setup",		 //97
+     "io_submit",		 //98
+     "ioctl",		 //99
+
+
+     "ioperm",		 //100
+     "iopl",		 //101
+     "ipc",		 //102
+     "kill",		 //103
+     "lchown",		 //104
+     "lchown32",		 //105
+     "lgetxattr",		 //106
+     "link",		 //107
+     "listxattr",		 //108
+     "llistxattr",		 //109
+
+
+     "lock",		 //110
+     "lookup_dcookie",		 //111
+     "lremovexattr",		 //112
+     "lseek",		 //113
+     "lsetxattr",		 //114
+     "lstat",		 //115
+     "lstat64",		 //116
+     "madvise",		 //117
+     "madvise1",		 //118
+     "mincore",		 //119
+
+
+     "mkdir",		 //120
+     "mknod",		 //121
+     "mlock",		 //122
+     "mlockall",		 //123
+     "mmap",		 //124
+     "mmap2",		 //125
+     "modify_ldt",		 //126
+     "mount",		 //127
+     "mprotect",		 //128
+     "mpx",		 //129
+
+
+     "mremap",		 //130
+     "msync",		 //131
+     "munlock",		 //132
+     "munlockall",		 //133
+     "munmap",		 //134
+     "nanosleep",		 //135
+     "nfsservctl",		 //136
+     "nice",		 //137
+     "oldfstat",		 //138
+     "oldlstat",		 //139
+
+
+     "oldolduname",		 //140
+     "oldstat",		 //141
+     "olduname",		 //142
+     "open",		 //143
+     "pause",		 //144
+     "personality",		 //145
+     "pipe",		 //146
+     "pivot_root",		 //147
+     "poll",		 //148
+     "prctl",		 //149
+
+
+     "pread64",		 //150
+     "prof",		 //151
+     "profil",		 //152
+     "ptrace",		 //153
+     "putpmsg",		 //154
+     "pwrite64",		 //155
+     "query_module",		 //156
+     "quotactl",		 //157
+     "read",		 //158
+     "readahead",		 //159
+
+
+     "readdir",		 //160
+     "readlink",		 //161
+     "readv",		 //162
+     "reboot",		 //163
+     "remap_file_pages",		 //164
+     "removexattr",		 //165
+     "rename",		 //166
+     "restart_syscall",		 //167
+     "rmdir",		 //168
+     "rt_sigaction",		 //169
+
+
+     "rt_sigpending",		 //170
+     "rt_sigprocmask",		 //171
+     "rt_sigqueueinfo",		 //172
+     "rt_sigreturn",		 //173
+     "rt_sigsuspend",		 //174
+     "rt_sigtimedwait",		 //175
+     "sched_get_priority_max",		 //176
+     "sched_get_priority_min",		 //177
+     "sched_getaffinity",		 //178
+     "sched_getparam",		 //179
+
+
+     "sched_getscheduler",		 //180
+     "sched_rr_get_interval",		 //181
+     "sched_setaffinity",		 //182
+     "sched_setparam",		 //183
+     "sched_setscheduler",		 //184
+     "sched_yield",		 //185
+     "select",		 //186
+     "sendfile",		 //187
+     "sendfile64",		 //188
+     "set_thread_area",		 //189
+
+
+     "set_tid_address",		 //190
+     "setdomainname",		 //191
+     "setfsgid",		 //192
+     "setfsgid32",		 //193
+     "setfsuid",		 //194
+     "setfsuid32",		 //195
+     "setgid",		 //196
+     "setgid32",		 //197
+     "setgroups",		 //198
+     "setgroups32",		 //199
+
+
+     "sethostname",		 //200
+     "setitimer",		 //201
+     "setpgid",		 //202
+     "setpriority",		 //203
+     "setregid",		 //204
+     "setregid32",		 //205
+     "setresgid",		 //206
+     "setresgid32",		 //207
+     "setresuid",		 //208
+     "setresuid32",		 //209
+
+
+     "setreuid",		 //210
+     "setreuid32",		 //211
+     "setrlimit",		 //212
+     "setsid",		 //213
+     "settimeofday",		 //214
+     "setuid",		 //215
+     "setuid32",		 //216
+     "setxattr",		 //217
+     "sgetmask",		 //218
+     "sigaction",		 //219
+
+
+     "sigaltstack",		 //220
+     "signal",		 //221
+     "sigpending",		 //222
+     "sigprocmask",		 //223
+     "sigreturn",		 //224
+     "sigsuspend",		 //225
+     "socketcall",		 //226
+     "ssetmask",		 //227
+     "stat",		 //228
+     "stat64",		 //229
+
+
+     "statfs",		 //230
+     "statfs64",		 //231
+     "stime",		 //232
+     "stty",		 //233
+     "swapoff",		 //234
+     "swapon",		 //235
+     "symlink",		 //236
+     "sync",		 //237
+     "sysfs",		 //238
+     "sysinfo",		 //239
+
+
+     "syslog",		 //240
+     "tgkill",		 //241
+     "time",		 //242
+     "timer_create",		 //243
+     "timer_delete",		 //244
+     "timer_getoverrun",		 //245
+     "timer_gettime",		 //246
+     "timer_settime",		 //247
+     "times",		 //248
+     "tkill",		 //249
+
+
+     "truncate",		 //250
+     "truncate64",		 //251
+     "ugetrlimit",		 //252
+     "ulimit",		 //253
+     "umask",		 //254
+     "umount",		 //255
+     "umount2",		 //256
+     "uname",		 //257
+     "unlink",		 //258
+     "uselib",		 //259
+
+
+     "ustat",		 //260
+     "utime",		 //261
+     "utimes",		 //262
+     "vfork",		 //263
+     "vhangup",		 //264
+     "vm86",		 //265
+     "vm86old",		 //266
+     "vserver",		 //267
+     "wait4",		 //268
+     "waitpid",		 //269
+
+
+     "write",		 //270
+     "writev",		 //271
+    };
+
+
+}
+
+const char *
+SystemCalls<Linux>::name(int num)
+{
+    if (num >= StandardNumber)
+        return 0;
+    else if (num >= 0)
+        return standard_strings[num];
+    else
+        return 0;
+}
diff --git a/kern/linux/linux_syscalls.hh b/kern/linux/linux_syscalls.hh
new file mode 100644
index 000000000..54d2391a8
--- /dev/null
+++ b/kern/linux/linux_syscalls.hh
@@ -0,0 +1,329 @@
+/*
+ * Copyright (c) 2003 The Regents of The University of Michigan
+ * 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;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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 COPYRIGHT
+ * OWNER OR CONTRIBUTORS 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.
+ */
+
+#ifndef __LINUX_SYSCALLS_HH__
+#define __LINUX_SYSCALLS_HH__
+
+#include "targetarch/syscalls.hh"
+#include "kern/linux/linux.hh"
+
+struct SystemCalls<Linux>
+{
+    enum {
+        syscall = 0,
+    llseek = 1,
+    newselect = 2,
+    sysctl = 3,
+    access = 4,
+    acct = 5,
+    adjtimex = 6,
+    afs_syscall = 7,
+    alarm = 8,
+    bdflush = 9,
+    _break = 10, /*renamed from break*/
+    brk = 11,
+    capget = 12,
+    capset = 13,
+    chdir = 14,
+    chmod = 15,
+    chown = 16,
+    chown32 = 17,
+    chroot = 18,
+    clock_getres = 19,
+    clock_gettime = 20,
+    clock_nanosleep = 21,
+    clock_settime = 22,
+    clone = 23,
+    close = 24,
+    creat = 25,
+    create_module = 26,
+    delete_module = 27,
+    dup = 28,
+    dup2 = 29,
+    epoll_create = 30,
+    epoll_ctl = 31,
+    epoll_wait = 32,
+    execve = 33,
+    exit = 34,
+    exit_group = 35,
+    fadvise64 = 36,
+    fadvise64_64 = 37,
+    fchdir = 38,
+    fchmod = 39,
+    fchown = 40,
+    fchown32 = 41,
+    fcntl = 42,
+    fcntl64 = 43,
+    fdatasync = 44,
+    fgetxattr = 45,
+    flistxattr = 46,
+    flock = 47,
+    fork = 48,
+    fremovexattr = 49,
+    fsetxattr = 50,
+    fstat = 51,
+    fstat64 = 52,
+    fstatfs = 53,
+    fstatfs64 = 54,
+    fsync = 55,
+    ftime = 56,
+    ftruncate = 57,
+    ftruncate64 = 58,
+    futex = 59,
+    get_kernel_syms = 60,
+    get_thread_area = 61,
+    getcwd = 62,
+    getdents = 63,
+    getdents64 = 64,
+    getegid = 65,
+    getegid32 = 66,
+    geteuid = 67,
+    geteuid32 = 68,
+    getgid = 69,
+    getgid32 = 70,
+    getgroups = 71,
+    getgroups32 = 72,
+    getitimer = 73,
+    getpgid = 74,
+    getpgrp = 75,
+    getpid = 76,
+    getpmsg = 77,
+    getppid = 78,
+    getpriority = 79,
+    getresgid = 80,
+    getresgid32 = 81,
+    getresuid = 82,
+    getresuid32 = 83,
+    getrlimit = 84,
+    getrusage = 85,
+    getsid = 86,
+    gettid = 87,
+    gettimeofday = 88,
+    getuid = 89,
+    getuid32 = 90,
+    getxattr = 91,
+    gtty = 92,
+    idle = 93,
+    init_module = 94,
+    io_cancel = 95,
+    io_destroy = 96,
+    io_getevents = 97,
+    io_setup = 98,
+    io_submit = 99,
+    ioctl = 100,
+    ioperm = 101,
+    iopl = 102,
+    ipc = 103,
+    kill = 104,
+    lchown = 105,
+    lchown32 = 106,
+    lgetxattr = 107,
+    link = 108,
+    listxattr = 109,
+    llistxattr = 110,
+    lock = 111,
+    lookup_dcookie = 112,
+    lremovexattr = 113,
+    lseek = 114,
+    lsetxattr = 115,
+    lstat = 116,
+    lstat64 = 117,
+    madvise = 118,
+    madvise1 = 119,
+    mincore = 120,
+    mkdir = 121,
+    mknod = 122,
+    mlock = 123,
+    mlockall = 124,
+    mmap = 125,
+    mmap2 = 126,
+    modify_ldt = 127,
+    mount = 128,
+    mprotect = 129,
+    mpx = 130,
+    mremap = 131,
+    msync = 132,
+    munlock = 133,
+    munlockall = 134,
+    munmap = 135,
+    nanosleep = 136,
+    nfsservctl = 137,
+    nice = 138,
+    oldfstat = 139,
+    oldlstat = 140,
+    oldolduname = 141,
+    oldstat = 142,
+    olduname = 143,
+    open = 144,
+    pause = 145,
+    personality = 146,
+    pipe = 147,
+    pivot_root = 148,
+    poll = 149,
+    prctl = 150,
+    pread64 = 151,
+    prof = 152,
+    profil = 153,
+    ptrace = 154,
+    putpmsg = 155,
+    pwrite64 = 156,
+    query_module = 157,
+    quotactl = 158,
+    read = 159,
+    readahead = 160,
+    readdir = 161,
+    readlink = 162,
+    readv = 163,
+    reboot = 164,
+    remap_file_pages = 165,
+    removexattr = 166,
+    rename = 167,
+    restart_syscall = 168,
+    rmdir = 169,
+    rt_sigaction = 170,
+    rt_sigpending = 171,
+    rt_sigprocmask = 172,
+    rt_sigqueueinfo = 173,
+    rt_sigreturn = 174,
+    rt_sigsuspend = 175,
+    rt_sigtimedwait = 176,
+    sched_get_priority_max = 177,
+    sched_get_priority_min = 178,
+    sched_getaffinity = 179,
+    sched_getparam = 180,
+    sched_getscheduler = 181,
+    sched_rr_get_interval = 182,
+    sched_setaffinity = 183,
+    sched_setparam = 184,
+    sched_setscheduler = 185,
+    sched_yield = 186,
+    select = 187,
+    sendfile = 188,
+    sendfile64 = 189,
+    set_thread_area = 190,
+    set_tid_address = 191,
+    setdomainname = 192,
+    setfsgid = 193,
+    setfsgid32 = 194,
+    setfsuid = 195,
+    setfsuid32 = 196,
+    setgid = 197,
+    setgid32 = 198,
+    setgroups = 199,
+    setgroups32 = 200,
+    sethostname = 201,
+    setitimer = 202,
+    setpgid = 203,
+    setpriority = 204,
+    setregid = 205,
+    setregid32 = 206,
+    setresgid = 207,
+    setresgid32 = 208,
+    setresuid = 209,
+    setresuid32 = 210,
+    setreuid = 211,
+    setreuid32 = 212,
+    setrlimit = 213,
+    setsid = 214,
+    settimeofday = 215,
+    setuid = 216,
+    setuid32 = 217,
+    setxattr = 218,
+    sgetmask = 219,
+    sigaction = 220,
+    sigaltstack = 221,
+    signal = 222,
+    sigpending = 223,
+    sigprocmask = 224,
+    sigreturn = 225,
+    sigsuspend = 226,
+    socketcall = 227,
+    ssetmask = 228,
+    stat = 229,
+    stat64 = 230,
+    statfs = 231,
+    statfs64 = 232,
+    stime = 233,
+    stty = 234,
+    swapoff = 235,
+    swapon = 236,
+    symlink = 237,
+    sync = 238,
+    sysfs = 239,
+    sysinfo = 240,
+    syslog = 241,
+    tgkill = 242,
+    time = 243,
+    timer_create = 244,
+    timer_delete = 245,
+    timer_getoverrun = 246,
+    timer_gettime = 247,
+    timer_settime = 248,
+    times = 249,
+    tkill = 250,
+    truncate = 251,
+    truncate64 = 252,
+    ugetrlimit = 253,
+    ulimit = 254,
+    umask = 255,
+    umount = 256,
+    umount2 = 257,
+    uname = 258,
+    unlink = 259,
+    uselib = 260,
+    ustat = 261,
+    utime = 262,
+    utimes = 263,
+    vfork = 264,
+    vhangup = 265,
+    vm86 = 266,
+    vm86old = 267,
+    vserver = 268,
+    wait4 = 269,
+    waitpid = 270,
+    write = 271,
+    writev = 272,
+        StandardNumber
+    };
+
+    static const char *name(int num);
+
+    static bool validSyscallNumber(int num) {
+        return num < StandardNumber;
+    }
+
+    /* why does this exist, I don't think it is needed for linux */
+    static int convert(int syscall_num) {
+        if (!validSyscallNumber(syscall_num))
+            return -1;
+
+        return syscall_num ;
+    }
+};
+
+#endif // __LINUX_SYSCALLS_HH__
diff --git a/kern/linux/linux_system.cc b/kern/linux/linux_system.cc
new file mode 100644
index 000000000..fe655ad74
--- /dev/null
+++ b/kern/linux/linux_system.cc
@@ -0,0 +1,706 @@
+/*
+ * Copyright (c) 2003 The Regents of The University of Michigan
+ * 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;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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 COPYRIGHT
+ * OWNER OR CONTRIBUTORS 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 "base/loader/aout_object.hh"
+#include "base/loader/elf_object.hh"
+#include "base/loader/object_file.hh"
+#include "base/loader/symtab.hh"
+#include "base/remote_gdb.hh"
+#include "base/trace.hh"
+#include "cpu/exec_context.hh"
+#include "kern/linux/linux_events.hh"
+#include "kern/linux/linux_system.hh"
+#include "mem/functional_mem/memory_control.hh"
+#include "mem/functional_mem/physical_memory.hh"
+#include "sim/builder.hh"
+#include "targetarch/isa_traits.hh"
+#include "targetarch/vtophys.hh"
+
+extern SymbolTable *debugSymbolTable;
+
+//un-comment this to see the state of call stack when it changes.
+//#define SW_DEBUG
+
+using namespace std;
+
+LinuxSystem::LinuxSystem(const string _name, const uint64_t _init_param,
+                         MemoryController *_memCtrl, PhysicalMemory *_physmem,
+                         const string &kernel_path, const string &console_path,
+                         const string &palcode, const string &boot_osflags,
+                         const string &bootloader_path, const bool _bin)
+     : System(_name, _init_param, _memCtrl, _physmem, _bin), bin(_bin)
+{
+    kernelSymtab = new SymbolTable;
+    consoleSymtab = new SymbolTable;
+    bootloaderSymtab = new SymbolTable;
+
+    ObjectFile *kernel = createObjectFile(kernel_path);
+    if (kernel == NULL)
+        fatal("Could not load kernel file %s", kernel_path);
+
+    ObjectFile *console = createObjectFile(console_path);
+    if (console == NULL)
+        fatal("Could not load console file %s", console_path);
+
+    ObjectFile *bootloader = createObjectFile(bootloader_path);
+    if (bootloader == NULL)
+        fatal("Could not load bootloader file %s", bootloader_path);
+
+    if (!kernel->loadGlobalSymbols(kernelSymtab))
+        panic("could not load kernel symbols\n");
+    debugSymbolTable = kernelSymtab;
+
+    if (!console->loadGlobalSymbols(consoleSymtab))
+        panic("could not load console symbols\n");
+
+    if (!bootloader->loadGlobalSymbols(bootloaderSymtab))
+        panic("could not load bootloader symbols\n");
+
+    // Load pal file
+    ObjectFile *pal = createObjectFile(palcode);
+    if (pal == NULL)
+        fatal("Could not load PALcode file %s", palcode);
+    pal->loadSections(physmem, true);
+
+    // Load console file
+    console->loadSections(physmem, true);
+
+    // Load kernel file
+    kernel->loadSections(physmem, true);
+    kernelStart = kernel->textBase();
+    kernelEnd = kernel->bssBase() + kernel->bssSize();
+    /* FIXME: entrypoint not in kernel, but in bootloader,
+       variable should be re-named appropriately */
+    kernelEntry = kernel->entryPoint();
+
+
+    DPRINTF(Loader, "Kernel start = %#x\n"
+            "Kernel end   = %#x\n"
+            "Kernel entry = %#x\n",
+            kernelStart, kernelEnd, kernelEntry);
+
+    DPRINTF(Loader, "Kernel loaded...\n");
+
+    // Load bootloader file
+    bootloader->loadSections(physmem, true);
+    kernelEntry = bootloader->entryPoint();
+    kernelStart = bootloader->textBase();
+    DPRINTF(Loader, "Bootloader entry at %#x\n", kernelEntry);
+
+#ifdef FS_MEASURE
+    //INSTRUMENTATION CODEGEN BEGIN ONE
+    if (bin == true) {
+        esIntrBin = new Statistics::MainBin(name() + " es_intr");
+        fnBins.insert(make_pair("es_intr", esIntrBin));
+
+        esRxeofBin = new Statistics::MainBin(name() + " es_rxeof");
+        fnBins.insert(make_pair("es_rxeof", esRxeofBin));
+
+        esNewbufBin = new Statistics::MainBin(name() + " es_newbuf");
+        fnBins.insert(make_pair("es_newbuf", esNewbufBin));
+
+        esDmaLoadBin = new Statistics::MainBin(name() + " es_dma_load");
+        fnBins.insert(make_pair("es_dma_load", esDmaLoadBin));
+
+        dmaMapLoadBin = new Statistics::MainBin(name() + " dma_map_load");
+        fnBins.insert(make_pair("dma_map_load", dmaMapLoadBin));
+
+        etherInputBin = new Statistics::MainBin(name() + " ether_input");
+        fnBins.insert(make_pair("ether_input", etherInputBin));
+
+        netisrInputBin = new Statistics::MainBin(name() + " netisr_input");
+        fnBins.insert(make_pair("netisr_input", netisrInputBin));
+
+        schednetisrIsrBin = new Statistics::MainBin(name() + " schednetisr_isr");
+        fnBins.insert(make_pair("schednetisr_isr", schednetisrIsrBin));
+
+        ipintrBin = new Statistics::MainBin(name() + " ipintr");
+        fnBins.insert(make_pair("ipintr", ipintrBin));
+
+        ipDooptionsBin = new Statistics::MainBin(name() + " ip_dooptions");
+        fnBins.insert(make_pair("ip_dooptions", ipDooptionsBin));
+
+        ipReassBin = new Statistics::MainBin(name() + " ip_reass");
+        fnBins.insert(make_pair("ip_reass", ipReassBin));
+
+        tcpInputBin = new Statistics::MainBin(name() + " tcp_input");
+        fnBins.insert(make_pair("tcp_input", tcpInputBin));
+
+        sbappendBin = new Statistics::MainBin(name() + " sbappend");
+        fnBins.insert(make_pair("sbappend", sbappendBin));
+
+        readBin = new Statistics::MainBin(name() + " read");
+        fnBins.insert(make_pair("read", readBin));
+
+        sooReadBin = new Statistics::MainBin(name() + " soo_read");
+        fnBins.insert(make_pair("soo_read", sooReadBin));
+
+        orecvBin = new Statistics::MainBin(name() + " orecv");
+        fnBins.insert(make_pair("orecv", orecvBin));
+
+        recvitBin = new Statistics::MainBin(name() + " recvit");
+        fnBins.insert(make_pair("recvit", recvitBin));
+
+        soreceiveBin = new Statistics::MainBin(name() + " soreceive");
+        fnBins.insert(make_pair("soreceive", soreceiveBin));
+
+        osendBin = new Statistics::MainBin(name() + " osend");
+        fnBins.insert(make_pair("osend", osendBin));
+
+        writeBin = new Statistics::MainBin(name() + " write");
+        fnBins.insert(make_pair("write", writeBin));
+
+        sooWriteBin = new Statistics::MainBin(name() + " soo_write");
+        fnBins.insert(make_pair("soo_write", sooWriteBin));
+
+        senditBin = new Statistics::MainBin(name() + " sendit");
+        fnBins.insert(make_pair("sendit", senditBin));
+
+        sosendBin = new Statistics::MainBin(name() + " sosend");
+        fnBins.insert(make_pair("sosend", sosendBin));
+
+        tcpSosendBin = new Statistics::MainBin(name() + " tcp_sosend");
+        fnBins.insert(make_pair("tcp_sosend", tcpSosendBin));
+
+        tcpOutputBin = new Statistics::MainBin(name() + " tcp_output");
+        fnBins.insert(make_pair("tcp_output", tcpOutputBin));
+
+        ipOutputBin = new Statistics::MainBin(name() + " ip_output");
+        fnBins.insert(make_pair("ip_output", ipOutputBin));
+
+        etherOutputBin = new Statistics::MainBin(name() + " ether_output");
+        fnBins.insert(make_pair("ether_output", etherOutputBin));
+
+        esStartBin = new Statistics::MainBin(name() + " es_start");
+        fnBins.insert(make_pair("es_start", esStartBin));
+
+        esTransmitBin = new Statistics::MainBin(name() + " es_transmit");
+        fnBins.insert(make_pair("es_transmit", esTransmitBin));
+
+        esTxeofBin = new Statistics::MainBin(name() + " es_txeof");
+        fnBins.insert(make_pair("es_txeof", esTxeofBin));
+
+        idleThreadBin = new Statistics::MainBin(name() + " idle_thread");
+        fnBins.insert(make_pair("idle_thread", idleThreadBin));
+
+    }
+    //INSTRUMENTATION CODEGEN END
+#endif //FS_MEASURE
+
+    kernelPanicEvent = new BreakPCEvent(&pcEventQueue, "kernel panic");
+    consolePanicEvent = new BreakPCEvent(&pcEventQueue, "console panic");
+    badaddrEvent = new LinuxBadAddrEvent(&pcEventQueue, "badaddr");
+    skipPowerStateEvent = new LinuxSkipFuncEvent(&pcEventQueue,
+                                            "tl_v48_capture_power_state");
+    skipScavengeBootEvent = new LinuxSkipFuncEvent(&pcEventQueue,
+                                              "pmap_scavenge_boot");
+    printfEvent = new LinuxPrintfEvent(&pcEventQueue, "printf");
+   /* debugPrintfEvent = new DebugPrintfEvent(&pcEventQueue,
+                                            "debug_printf", false);
+    debugPrintfrEvent = new DebugPrintfEvent(&pcEventQueue,
+                                             "debug_printfr", true);
+    dumpMbufEvent = new DumpMbufEvent(&pcEventQueue, "dump_mbuf");
+*/
+#ifdef FS_MEASURE
+    //INSTRUMENTATION CODEGEN BEGIN TWO
+    if (bin == true) {
+          esIntrEvent = new FnEvent(&pcEventQueue, "es_intr", this);
+          esRxeofEvent = new FnEvent(&pcEventQueue, "es_rxeof", this);
+          esNewbufEvent = new FnEvent(&pcEventQueue, "es_newbuf", this);
+          esDmaLoadEvent = new FnEvent(&pcEventQueue, "es_dma_load", this);
+          dmaMapLoadEvent = new FnEvent(&pcEventQueue, "dma_map_load", this);
+          etherInputEvent = new FnEvent(&pcEventQueue, "ether_input", this);
+          netisrInputEvent = new FnEvent(&pcEventQueue, "netisr_input", this);
+          schednetisrIsrEvent = new FnEvent(&pcEventQueue, "schednetisr_isr", this);
+          ipintrEvent = new FnEvent(&pcEventQueue, "ipintr", this);
+          ipDooptionsEvent = new FnEvent(&pcEventQueue, "ip_dooptions", this);
+          ipReassEvent = new FnEvent(&pcEventQueue, "ip_reass", this);
+          tcpInputEvent = new FnEvent(&pcEventQueue, "tcp_input", this);
+          sbappendEvent = new FnEvent(&pcEventQueue, "sbappend", this);
+          readEvent = new FnEvent(&pcEventQueue, "read", this);
+          sooReadEvent = new FnEvent(&pcEventQueue, "soo_read", this);
+          orecvEvent = new FnEvent(&pcEventQueue, "orecv", this);
+          recvitEvent = new FnEvent(&pcEventQueue, "recvit", this);
+          soreceiveEvent = new FnEvent(&pcEventQueue, "soreceive", this);
+          osendEvent = new FnEvent(&pcEventQueue, "osend", this);
+          writeEvent = new FnEvent(&pcEventQueue, "write", this);
+          sooWriteEvent = new FnEvent(&pcEventQueue, "soo_write", this);
+          senditEvent = new FnEvent(&pcEventQueue, "sendit", this);
+          sosendEvent = new FnEvent(&pcEventQueue, "sosend", this);
+          tcpSosendEvent = new FnEvent(&pcEventQueue, "tcp_sosend", this);
+          tcpOutputEvent = new FnEvent(&pcEventQueue, "tcp_output", this);
+          ipOutputEvent = new FnEvent(&pcEventQueue, "ip_output", this);
+          etherOutputEvent = new FnEvent(&pcEventQueue, "ether_output", this);
+          esStartEvent = new FnEvent(&pcEventQueue, "es_start", this);
+          esTransmitEvent = new FnEvent(&pcEventQueue, "es_transmit", this);
+          esTxeofEvent = new FnEvent(&pcEventQueue, "es_txeof", this);
+          idleThreadEvent = new FnEvent(&pcEventQueue, "idle_thread", this);
+    }
+    //INSTRUMENTATION CODEGEN END
+#endif //FS_MEASURE
+
+    Addr addr = 0;
+    if (kernelSymtab->findAddress("enable_async_printf", addr)) {
+        Addr paddr = vtophys(physmem, addr);
+        uint8_t *enable_async_printf =
+            physmem->dma_addr(paddr, sizeof(uint32_t));
+
+        if (enable_async_printf)
+            *(uint32_t *)enable_async_printf = 0;
+    }
+
+    if (consoleSymtab->findAddress("env_booted_osflags", addr)) {
+        Addr paddr = vtophys(physmem, addr);
+        char *osflags = (char *)physmem->dma_addr(paddr, sizeof(uint32_t));
+
+        if (osflags)
+            strcpy(osflags, boot_osflags.c_str());
+    }
+
+    if (kernelSymtab->findAddress("panic", addr))
+        kernelPanicEvent->schedule(addr);
+    else
+        panic("could not find kernel symbol \'panic\'");
+
+    if (consoleSymtab->findAddress("panic", addr))
+        consolePanicEvent->schedule(addr);
+
+    if (kernelSymtab->findAddress("badaddr", addr))
+        badaddrEvent->schedule(addr);
+   // else
+        //panic("could not find kernel symbol \'badaddr\'");
+
+    if (kernelSymtab->findAddress("tl_v48_capture_power_state", addr))
+        skipPowerStateEvent->schedule(addr);
+
+    if (kernelSymtab->findAddress("pmap_scavenge_boot", addr))
+        skipScavengeBootEvent->schedule(addr);
+
+#if TRACING_ON
+    if (kernelSymtab->findAddress("printk", addr))
+        printfEvent->schedule(addr);
+
+    if (kernelSymtab->findAddress("m5printf", addr))
+        debugPrintfEvent->schedule(addr);
+
+    if (kernelSymtab->findAddress("m5printfr", addr))
+        debugPrintfrEvent->schedule(addr);
+
+    if (kernelSymtab->findAddress("m5_dump_mbuf", addr))
+        dumpMbufEvent->schedule(addr);
+#endif
+
+#ifdef FS_MEASURE
+    //INSTRUMENTATION CODEGEN BEGIN THREE
+    if (bin == true) {
+        if (kernelSymtab->findAddress("es_intr", addr))
+            esIntrEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'es_intr\'");
+
+        if (kernelSymtab->findAddress("es_rxeof", addr))
+            esRxeofEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'es_rxeof\'");
+
+        if (kernelSymtab->findAddress("es_newbuf", addr))
+            esNewbufEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'es_newbuf\'");
+
+        if (kernelSymtab->findAddress("es_dma_load", addr))
+            esDmaLoadEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'es_dma_load\'");
+
+        if (kernelSymtab->findAddress("dma_map_load", addr))
+            dmaMapLoadEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'dma_map_load\'");
+
+        if (kernelSymtab->findAddress("ether_input", addr))
+            etherInputEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'ether_input\'");
+
+        if (kernelSymtab->findAddress("netisr_input", addr))
+            netisrInputEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'netisr_input\'");
+
+        if (kernelSymtab->findAddress("schednetisr_isr", addr))
+            schednetisrIsrEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'schednetisr_isr\'");
+
+        if (kernelSymtab->findAddress("ipintr", addr))
+            ipintrEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'ipintr\'");
+
+        if (kernelSymtab->findAddress("ip_dooptions", addr))
+            ipDooptionsEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'ip_dooptions\'");
+
+        if (kernelSymtab->findAddress("ip_reass", addr))
+            ipReassEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'ip_reass\'");
+
+        if (kernelSymtab->findAddress("tcp_input", addr))
+            tcpInputEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'tcp_input\'");
+
+        if (kernelSymtab->findAddress("sbappend", addr))
+            sbappendEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'sbappend\'");
+
+        if (kernelSymtab->findAddress("read", addr))
+            readEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'read\'");
+
+        if (kernelSymtab->findAddress("soo_read", addr))
+            sooReadEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'soo_read\'");
+
+        if (kernelSymtab->findAddress("orecv", addr))
+            orecvEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'orecv\'");
+
+        if (kernelSymtab->findAddress("recvit", addr))
+            recvitEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'recvit\'");
+
+        if (kernelSymtab->findAddress("soreceive", addr))
+            soreceiveEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'soreceive\'");
+
+        if (kernelSymtab->findAddress("osend", addr))
+            osendEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'osend\'");
+
+        if (kernelSymtab->findAddress("write", addr))
+            writeEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'write\'");
+
+        if (kernelSymtab->findAddress("soo_write", addr))
+            sooWriteEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'soo_write\'");
+
+        if (kernelSymtab->findAddress("sendit", addr))
+            senditEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'sendit\'");
+
+        if (kernelSymtab->findAddress("sosend", addr))
+            sosendEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'sosend\'");
+
+        if (kernelSymtab->findAddress("tcp_sosend", addr))
+            tcpSosendEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'tcp_sosend\'");
+
+        if (kernelSymtab->findAddress("tcp_output", addr))
+            tcpOutputEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'tcp_output\'");
+
+        if (kernelSymtab->findAddress("ip_output", addr))
+            ipOutputEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'ip_output\'");
+
+        if (kernelSymtab->findAddress("ether_output", addr))
+            etherOutputEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'ether_output\'");
+
+        if (kernelSymtab->findAddress("es_start", addr))
+            esStartEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'es_start\'");
+
+        if (kernelSymtab->findAddress("es_transmit", addr))
+            esTransmitEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'es_transmit\'");
+
+        if (kernelSymtab->findAddress("es_txeof", addr))
+            esTxeofEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'es_txeof\'");
+
+        if (kernelSymtab->findAddress("idle_thread", addr))
+            idleThreadEvent->schedule(addr);
+        else
+            panic("could not find kernel symbol \'idle_thread\'");
+
+    }
+    //INSTRUMENTATION CODEGEN END
+     if (bin == true) {
+        fnCalls
+            .name(name() + ":fnCalls")
+            .desc("all fn calls being tracked")
+            ;
+
+        populateMap("es_intr", "");
+        populateMap("es_rxeof", "es_intr");
+        populateMap("es_newbuf", "es_rxeof");
+        populateMap("es_dma_load", "es_newbuf");
+        populateMap("dma_map_load", "es_dma_load");
+        populateMap("ether_input", "es_rxeof");
+        populateMap("netisr_input", "ether_input");
+        populateMap("schednetisr_isr", "netisr_input");
+
+        populateMap("ipintr", "");
+        populateMap("ip_dooptions", "ipintr");
+        populateMap("ip_reass", "ipintr");
+        populateMap("tcp_input", "ipintr");
+        populateMap("sbappend", "tcp_input");
+
+        populateMap("read", "");
+        populateMap("orecv", "");
+        populateMap("soo_read", "read");
+        populateMap("recvit", "orecv");
+        populateMap("soreceive", "recvit");
+        populateMap("soreceive", "soo_read");
+
+        populateMap("write", "");
+        populateMap("osend", "");
+        populateMap("soo_write", "write");
+        populateMap("sendit", "osend");
+        populateMap("sosend", "sendit");
+        populateMap("sosend", "soo_write");
+        populateMap("tcp_sosend", "sosend");
+        populateMap("tcp_output", "tcp_sosend");
+        populateMap("ip_output", "tcp_output");
+        populateMap("ether_output", "ip_output");
+        populateMap("es_start", "ether_output");
+        populateMap("es_transmit", "es_start");
+
+        populateMap("es_txeof", "es_intr");
+
+        populateMap("idle_thread", "");
+    }
+#endif //FS_MEASURE
+}
+
+LinuxSystem::~LinuxSystem()
+{
+    delete kernel;
+    delete console;
+
+    delete kernelSymtab;
+    delete consoleSymtab;
+    delete bootloaderSymtab;
+
+    delete kernelPanicEvent;
+    delete consolePanicEvent;
+    delete badaddrEvent;
+    delete skipPowerStateEvent;
+    delete skipScavengeBootEvent;
+    delete printfEvent;
+    /*delete debugPrintfEvent;
+    delete debugPrintfrEvent;
+    delete dumpMbufEvent;
+*/
+#ifdef FS_MEASURE
+    //INSTRUMENTATION CODEGEN BEGIN FOUR
+    if (bin == true) {
+        delete esIntrEvent;
+        delete esRxeofEvent;
+        delete esNewbufEvent;
+        delete esDmaLoadEvent;
+        delete dmaMapLoadEvent;
+        delete etherInputEvent;
+        delete netisrInputEvent;
+        delete schednetisrIsrEvent;
+        delete ipintrEvent;
+        delete ipDooptionsEvent;
+        delete ipReassEvent;
+        delete tcpInputEvent;
+        delete sbappendEvent;
+        delete readEvent;
+        delete sooReadEvent;
+        delete orecvEvent;
+        delete recvitEvent;
+        delete soreceiveEvent;
+        delete osendEvent;
+        delete writeEvent;
+        delete sooWriteEvent;
+        delete senditEvent;
+        delete sosendEvent;
+        delete tcpSosendEvent;
+        delete tcpOutputEvent;
+        delete ipOutputEvent;
+        delete etherOutputEvent;
+        delete esStartEvent;
+        delete esTransmitEvent;
+        delete esTxeofEvent;
+        delete idleThreadEvent;
+    }
+    //INSTRUMENTATION CODEGEN END
+#endif //FS_MEASURE
+}
+
+int
+LinuxSystem::registerExecContext(ExecContext *xc)
+{
+    int xcIndex = System::registerExecContext(xc);
+
+    if (xcIndex == 0) {
+        // activate with zero delay so that we start ticking right
+        // away on cycle 0
+        xc->activate(0);
+    }
+
+    RemoteGDB *rgdb = new RemoteGDB(this, xc);
+    GDBListener *gdbl = new GDBListener(rgdb, 7000 + xcIndex);
+    gdbl->listen();
+
+    if (remoteGDB.size() <= xcIndex) {
+        remoteGDB.resize(xcIndex+1);
+    }
+
+    remoteGDB[xcIndex] = rgdb;
+
+    return xcIndex;
+}
+
+
+void
+LinuxSystem::replaceExecContext(ExecContext *xc, int xcIndex)
+{
+    System::replaceExecContext(xcIndex, xc);
+    remoteGDB[xcIndex]->replaceExecContext(xc);
+}
+
+bool
+LinuxSystem::breakpoint()
+{
+    return remoteGDB[0]->trap(ALPHA_KENTRY_IF);
+}
+
+#ifdef FS_MEASURE
+void
+LinuxSystem::populateMap(std::string callee, std::string caller)
+{
+    multimap<const string, string>::const_iterator i;
+    i = callerMap.insert(make_pair(callee, caller));
+    assert(i != callerMap.end() && "should not fail populating callerMap");
+}
+
+bool
+LinuxSystem::findCaller(std::string callee, std::string caller) const
+{
+    typedef multimap<const std::string, std::string>::const_iterator iter;
+    pair<iter, iter> range;
+
+    range = callerMap.equal_range(callee);
+    for (iter i = range.first; i != range.second; ++i) {
+        if ((*i).second == caller)
+            return true;
+    }
+    return false;
+}
+
+void
+LinuxSystem::dumpState(ExecContext *xc) const
+{
+#ifndef SW_DEBUG
+    return;
+#endif
+    if (xc->swCtx) {
+        stack<fnCall *> copy(xc->swCtx->callStack);
+        if (copy.empty())
+            return;
+        cprintf("xc->swCtx:\n");
+        fnCall *top;
+        cprintf("||   call: %d\n",xc->swCtx->calls);
+        for (top = copy.top(); !copy.empty(); copy.pop() ) {
+            top = copy.top();
+            cprintf("||  %13s : %s \n", top->name, top->myBin->name());
+        }
+    }
+}
+#endif //FS_MEASURE
+
+BEGIN_DECLARE_SIM_OBJECT_PARAMS(LinuxSystem)
+
+    Param<bool> bin;
+    SimObjectParam<MemoryController *> mem_ctl;
+    SimObjectParam<PhysicalMemory *> physmem;
+    Param<uint64_t> init_param;
+
+    Param<string> kernel_code;
+    Param<string> console_code;
+    Param<string> pal_code;
+    Param<string> boot_osflags;
+    Param<string> bootloader_code;
+
+END_DECLARE_SIM_OBJECT_PARAMS(LinuxSystem)
+
+BEGIN_INIT_SIM_OBJECT_PARAMS(LinuxSystem)
+
+    INIT_PARAM_DFLT(bin, "is this system to be binned", false),
+    INIT_PARAM(mem_ctl, "memory controller"),
+    INIT_PARAM(physmem, "phsyical memory"),
+    INIT_PARAM_DFLT(init_param, "numerical value to pass into simulator", 0),
+    INIT_PARAM(kernel_code, "file that contains the kernel code"),
+    INIT_PARAM(console_code, "file that contains the console code"),
+    INIT_PARAM(pal_code, "file that contains palcode"),
+    INIT_PARAM_DFLT(boot_osflags, "flags to pass to the kernel during boot",
+                                   "a"),
+    INIT_PARAM(bootloader_code, "file that contains the bootloader")
+
+
+END_INIT_SIM_OBJECT_PARAMS(LinuxSystem)
+
+CREATE_SIM_OBJECT(LinuxSystem)
+{
+    LinuxSystem *sys = new LinuxSystem(getInstanceName(), init_param, mem_ctl,
+                                       physmem, kernel_code, console_code,
+                                       pal_code, boot_osflags, bootloader_code, bin);
+
+    return sys;
+}
+
+REGISTER_SIM_OBJECT("LinuxSystem", LinuxSystem)
diff --git a/kern/linux/linux_system.hh b/kern/linux/linux_system.hh
new file mode 100644
index 000000000..cfb20f6dc
--- /dev/null
+++ b/kern/linux/linux_system.hh
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2003 The Regents of The University of Michigan
+ * 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;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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 COPYRIGHT
+ * OWNER OR CONTRIBUTORS 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.
+ */
+
+#ifndef __LINUX_SYSTEM_HH__
+#define __LINUX_SYSTEM_HH__
+
+#include <vector>
+
+#include "sim/system.hh"
+#include "targetarch/isa_traits.hh"
+
+#ifdef FS_MEASURE
+#include <map>
+#endif
+
+class ExecContext;
+class ElfObject;
+class SymbolTable;
+
+class BreakPCEvent;
+class LinuxBadAddrEvent;
+class LinuxSkipFuncEvent;
+class LinuxPrintfEvent;
+class LinuxDebugPrintfEvent;
+class LinuxDumpMbufEvent;
+#ifdef FS_MEASURE
+class FnEvent;
+#endif
+class AlphaArguments;
+
+class LinuxSystem : public System
+{
+  private:
+    ElfObject *kernel;
+    ElfObject *console;
+    ElfObject *bootloader;
+
+    SymbolTable *kernelSymtab;
+    SymbolTable *bootloaderSymtab;
+    SymbolTable *consoleSymtab;
+
+#ifdef FS_MEASURE
+    //INSTRUMENTATION CODEGEN BEGIN ONE
+    Statistics::MainBin *esIntrBin;
+    Statistics::MainBin *esRxeofBin;
+    Statistics::MainBin *esNewbufBin;
+    Statistics::MainBin *esDmaLoadBin;
+    Statistics::MainBin *dmaMapLoadBin;
+    Statistics::MainBin *etherInputBin;
+    Statistics::MainBin *netisrInputBin;
+    Statistics::MainBin *schednetisrIsrBin;
+    Statistics::MainBin *ipintrBin;
+    Statistics::MainBin *ipDooptionsBin;
+    Statistics::MainBin *ipReassBin;
+    Statistics::MainBin *tcpInputBin;
+    Statistics::MainBin *sbappendBin;
+    Statistics::MainBin *readBin;
+    Statistics::MainBin *sooReadBin;
+    Statistics::MainBin *orecvBin;
+    Statistics::MainBin *recvitBin;
+    Statistics::MainBin *soreceiveBin;
+    Statistics::MainBin *osendBin;
+    Statistics::MainBin *writeBin;
+    Statistics::MainBin *sooWriteBin;
+    Statistics::MainBin *senditBin;
+    Statistics::MainBin *sosendBin;
+    Statistics::MainBin *tcpSosendBin;
+    Statistics::MainBin *tcpOutputBin;
+    Statistics::MainBin *ipOutputBin;
+    Statistics::MainBin *etherOutputBin;
+    Statistics::MainBin *esStartBin;
+    Statistics::MainBin *esTransmitBin;
+    Statistics::MainBin *esTxeofBin;
+    Statistics::MainBin *idleThreadBin;
+    //INSTRUMENTATION CODEGEN END
+#endif //FS_MEASURE
+
+    BreakPCEvent *kernelPanicEvent;
+    BreakPCEvent *consolePanicEvent;
+    LinuxBadAddrEvent *badaddrEvent;
+    LinuxSkipFuncEvent *skipPowerStateEvent;
+    LinuxSkipFuncEvent *skipScavengeBootEvent;
+    LinuxPrintfEvent *printfEvent;
+    LinuxDebugPrintfEvent *debugPrintfEvent;
+    LinuxDebugPrintfEvent *debugPrintfrEvent;
+    LinuxDumpMbufEvent *dumpMbufEvent;
+#ifdef FS_MEASURE
+    //INSTRUMENTATION CODEGEN BEGIN TWO
+    FnEvent *esIntrEvent;
+    FnEvent *esRxeofEvent;
+    FnEvent *esNewbufEvent;
+    FnEvent *esDmaLoadEvent;
+    FnEvent *dmaMapLoadEvent;
+    FnEvent *etherInputEvent;
+    FnEvent *netisrInputEvent;
+    FnEvent *schednetisrIsrEvent;
+    FnEvent *ipintrEvent;
+    FnEvent *ipDooptionsEvent;
+    FnEvent *ipReassEvent;
+    FnEvent *tcpInputEvent;
+    FnEvent *sbappendEvent;
+    FnEvent *readEvent;
+    FnEvent *sooReadEvent;
+    FnEvent *orecvEvent;
+    FnEvent *recvitEvent;
+    FnEvent *soreceiveEvent;
+    FnEvent *osendEvent;
+    FnEvent *writeEvent;
+    FnEvent *sooWriteEvent;
+    FnEvent *senditEvent;
+    FnEvent *sosendEvent;
+    FnEvent *tcpSosendEvent;
+    FnEvent *tcpOutputEvent;
+    FnEvent *ipOutputEvent;
+    FnEvent *etherOutputEvent;
+    FnEvent *esStartEvent;
+    FnEvent *esTransmitEvent;
+    FnEvent *esTxeofEvent;
+    FnEvent *idleThreadEvent;
+    //INSTRUMENTATION CODEGEN END
+#endif //FS_MEASURE
+
+  private:
+
+    Addr kernelStart;
+    Addr kernelEnd;
+    Addr kernelEntry;
+    bool bin;
+
+#ifdef FS_MEASURE
+    std::multimap<const std::string, std::string> callerMap;
+    void populateMap(std::string caller, std::string callee);
+#endif
+
+  public:
+    std::vector<RemoteGDB *>   remoteGDB;
+    std::vector<GDBListener *> gdbListen;
+
+  public:
+    LinuxSystem(const std::string _name,
+                const uint64_t _init_param,
+                MemoryController *_memCtrl,
+                PhysicalMemory *_physmem,
+                const std::string &kernel_path,
+                const std::string &console_path,
+                const std::string &palcode,
+                const std::string &boot_osflags,
+        const std::string &bootloader_path,
+                                const bool _bin);
+    ~LinuxSystem();
+
+    int registerExecContext(ExecContext *xc);
+    void replaceExecContext(ExecContext *xc, int xcIndex);
+
+    Addr getKernelStart() const { return kernelStart; }
+    Addr getKernelEnd() const { return kernelEnd; }
+    Addr getKernelEntry() const { return kernelEntry; }
+    bool breakpoint();
+
+    static void Printf(AlphaArguments args);
+    static void DumpMbuf(AlphaArguments args);
+
+#ifdef FS_MEASURE
+    bool findCaller(std::string callee, std::string caller) const;
+    void dumpState(ExecContext *xc) const;
+#endif //FS_MEASURE
+};
+
+#endif // __LINUX_SYSTEM_HH__