diff -r 74e3c7359393 src/sim/process.cc --- a/src/sim/process.cc Wed Apr 22 20:22:29 2015 -0700 +++ b/src/sim/process.cc Thu Apr 23 16:22:41 2015 +0100 @@ -77,6 +77,7 @@ #include "arch/mips/linux/process.hh" #elif THE_ISA == ARM_ISA #include "arch/arm/linux/process.hh" +#include "arch/arm/freebsd/process.hh" #elif THE_ISA == X86_ISA #include "arch/x86/linux/process.hh" #elif THE_ISA == POWER_ISA @@ -736,6 +737,15 @@ objFile->getArch()); } break; + case ObjectFile::FreeBSD: + if (arch == ObjectFile::Arm64) { + process = new ArmFreebsdProcess64(params, objFile, + objFile->getArch()); + } else { + process = new ArmFreebsdProcess32(params, objFile, + objFile->getArch()); + } + break; case ObjectFile::LinuxArmOABI: fatal("M5 does not support ARM OABI binaries. Please recompile with an" " EABI compiler."); diff -r 74e3c7359393 src/kern/freebsd/events.hh --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/kern/freebsd/events.hh Thu Apr 23 16:22:41 2015 +0100 @@ -0,0 +1,66 @@ +/*- + * Copyright (c) 2015 Ruslan Bukin + * All rights reserved. + * + * This software was developed by the University of Cambridge Computer + * Laboratory as part of the CTSRD Project, with support from the UK Higher + * Education Innovation Fund (HEIF). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 __KERN_FREEBSD_EVENTS_HH__ +#define __KERN_FREEBSD_EVENTS_HH__ + +#include "kern/system_events.hh" + +namespace FreeBSD { + +/** A class to skip udelay() and related calls in the kernel. + * This class has two additional parameters that take the argument to udelay and + * manipulated it to come up with ns and eventually ticks to quiesce for. + * See descriptions of argDivToNs and argMultToNs below. + */ +class UDelayEvent : public SkipFuncEvent +{ + private: + /** value to divide arg by to create ns. This is present beacues the linux + * kernel code sometime precomputes the first multiply that is done in + * udelay() if the parameter is a constant. We need to undo it so here is + * how. */ + uint64_t argDivToNs; + + /** value to multiple arg by to create ns. Nominally, this is 1000 to + * convert us to ns, but since linux can do some preprocessing of constant + * values something else might be required. */ + uint64_t argMultToNs; + + public: + UDelayEvent(PCEventQueue *q, const std::string &desc, Addr addr, + uint64_t mult, uint64_t div) + : SkipFuncEvent(q, desc, addr), argDivToNs(div), argMultToNs(mult) {} + virtual void process(ThreadContext *xc); +}; + +} + +#endif diff -r 74e3c7359393 src/kern/freebsd/events.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/kern/freebsd/events.cc Thu Apr 23 16:22:41 2015 +0100 @@ -0,0 +1,68 @@ +/*- + * Copyright (c) 2015 Ruslan Bukin + * All rights reserved. + * + * This software was developed by the University of Cambridge Computer + * Laboratory as part of the CTSRD Project, with support from the UK Higher + * Education Innovation Fund (HEIF). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 + +#include "arch/utility.hh" +#include "base/trace.hh" +#include "cpu/thread_context.hh" +#include "debug/DebugPrintf.hh" +#include "kern/freebsd/events.hh" +#include "kern/system_events.hh" +#include "sim/arguments.hh" +#include "sim/pseudo_inst.hh" +#include "sim/system.hh" + +namespace FreeBSD { + +void +UDelayEvent::process(ThreadContext *tc) +{ + int arg_num; + + arg_num = 0; + + // Get the time in native size + uint64_t time = TheISA::getArgument(tc, arg_num, (uint16_t)-1, false); + + //DPRINTFN("DELAY(%d)\n", time); + + // convert parameter to ns + if (argDivToNs) + time /= argDivToNs; + + time *= argMultToNs; + + SkipFuncEvent::process(tc); + + PseudoInst::quiesceNs(tc, time); +} + +} // namespace FreeBSD diff -r 74e3c7359393 src/kern/freebsd/freebsd.hh --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/kern/freebsd/freebsd.hh Thu Apr 23 16:22:41 2015 +0100 @@ -0,0 +1,119 @@ +/*- + * Copyright (c) 2015 Ruslan Bukin + * All rights reserved. + * + * This software was developed by the University of Cambridge Computer + * Laboratory as part of the CTSRD Project, with support from the UK Higher + * Education Innovation Fund (HEIF). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 __FREEBSD_HH__ +#define __FREEBSD_HH__ + +#include "base/types.hh" + +#include + +#include "kern/operatingsystem.hh" + +class ThreadContext; +class LiveProcess; + +/// +/// This class encapsulates the types, structures, constants, +/// functions, and syscall-number mappings specific to the Alpha FreeBSD +/// syscall interface. +/// +class FreeBSD : public OperatingSystem +{ + + public: + + //@{ + /// Basic FreeBSD types. + typedef uint64_t size_t; + typedef uint64_t off_t; + typedef int64_t time_t; + typedef int64_t clock_t; + typedef uint32_t uid_t; + typedef uint32_t gid_t; + //@} + + /// Clock ticks per second, for times(). + static const int M5_SC_CLK_TCK = 100; + + //@{ + /// ioctl() command codes. + static const unsigned TGT_TIOCGETA = 0x402c7413; + static const unsigned TGT_TIOCSETA = 0x802c7414; + static const unsigned TGT_TIOCSETAW = 0x802c7415; + static const unsigned TGT_FIONREAD = 0x4004667f; + //@} + + /// Return true for the ioctl codes for which we return ENOTTY + /// *without* printing a warning, since we know that ENOTTY is the + /// correct thing to return (and not just a sign that we don't + /// recognize the ioctl code. + static bool + isTtyReq(unsigned req) + { + switch (req) { + case TGT_TIOCGETA: + case TGT_TIOCSETA: + case TGT_TIOCSETAW: + case TGT_FIONREAD: + return true; + default: + return false; + } + } + + /// Resource constants for getrlimit(). + static const unsigned TGT_RLIMIT_CPU = 0; + static const unsigned TGT_RLIMIT_FSIZE = 1; + static const unsigned TGT_RLIMIT_DATA = 2; + static const unsigned TGT_RLIMIT_STACK = 3; + static const unsigned TGT_RLIMIT_CORE = 4; + static const unsigned TGT_RLIMIT_RSS = 5; + static const unsigned TGT_RLIMIT_MEMLOCK = 6; + static const unsigned TGT_RLIMIT_NPROC = 7; + static const unsigned TGT_RLIMIT_NOFILE = 8; + static const unsigned TGT_RLIMIT_SBSIZE = 9; + static const unsigned TGT_RLIMIT_VMEM = 10; + static const unsigned TGT_RLIMIT_AS = TGT_RLIMIT_VMEM; + static const unsigned TGT_RLIMIT_NPTS = 11; + static const unsigned TGT_RLIMIT_SWAP = 12; + static const unsigned TGT_RLIMIT_KQUEUES = 13; + + /// For getrusage(). + static const int TGT_RUSAGE_SELF = 0; + static const int TGT_RUSAGE_CHILDREN = -1; + static const int TGT_RUSAGE_THREAD = 1; + + // for *at syscalls + static const int TGT_AT_FDCWD = -100; + +}; // class FreeBSD + +#endif // __FREEBSD_HH__ diff -r 74e3c7359393 src/dev/terminal.cc --- a/src/dev/terminal.cc Wed Apr 22 20:22:29 2015 -0700 +++ b/src/dev/terminal.cc Thu Apr 23 16:22:41 2015 +0100 @@ -34,7 +34,11 @@ */ #include +#if defined(__FreeBSD__) +#include +#else #include +#endif #include #include diff -r 74e3c7359393 src/kern/SConscript --- a/src/kern/SConscript Wed Apr 22 20:22:29 2015 -0700 +++ b/src/kern/SConscript Thu Apr 23 16:22:41 2015 +0100 @@ -37,6 +37,7 @@ Source('linux/events.cc') Source('linux/linux.cc') Source('linux/printk.cc') +Source('freebsd/events.cc') Source('operatingsystem.cc') Source('system_events.cc') diff -r 74e3c7359393 src/base/vnc/vncserver.cc --- a/src/base/vnc/vncserver.cc Wed Apr 22 20:22:29 2015 -0700 +++ b/src/base/vnc/vncserver.cc Thu Apr 23 16:22:41 2015 +0100 @@ -44,7 +44,11 @@ #include #include +#if defined(__FreeBSD__) +#include +#else #include +#endif #include #include #include diff -r 74e3c7359393 src/dev/arm/gic_pl390.cc --- a/src/dev/arm/gic_pl390.cc Wed Apr 22 20:22:29 2015 -0700 +++ b/src/dev/arm/gic_pl390.cc Thu Apr 23 16:22:41 2015 +0100 @@ -525,7 +525,8 @@ } else { uint32_t int_num = 1 << intNumToBit(iar.ack_id); if (!(activeInt[intNumToWord(iar.ack_id)] & int_num)) - panic("Done handling interrupt that isn't active?\n"); + warn("Done handling interrupt that isn't active: %d\n", + intNumToBit(iar.ack_id)); activeInt[intNumToWord(iar.ack_id)] &= ~int_num; } updateRunPri(); diff -r 74e3c7359393 src/arch/generic/freebsd/threadinfo.hh --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/arch/generic/freebsd/threadinfo.hh Thu Apr 23 16:22:41 2015 +0100 @@ -0,0 +1,186 @@ +/* + * Copyright (c) 2004 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. + * + * Authors: Ali Saidi + * Nathan Binkert + * Dam Sunwoo + */ + +#ifndef __ARCH_GENERIC_FREEBSD_THREADINFO_HH__ +#define __ARCH_GENERIC_FREEBSD_THREADINFO_HH__ + +#include "cpu/thread_context.hh" +#include "sim/system.hh" +#include "sim/vptr.hh" + +namespace FreeBSD { + +class ThreadInfo +{ + private: + ThreadContext *tc; + System *sys; + Addr pcbb; + + template + bool + get_data(const char *symbol, T &data) + { + Addr addr = 0; + if (!sys->kernelSymtab->findAddress(symbol, addr)) { + warn_once("Unable to find kernel symbol %s\n", symbol); + warn_once("Kernel not compiled with task_struct info; can't get " + "currently executing task/process/thread name/ids!\n"); + return false; + } + + CopyOut(tc, &data, addr, sizeof(T)); + + data = TheISA::gtoh(data); + + return true; + } + + public: + ThreadInfo(ThreadContext *_tc, Addr _pcbb = 0) + : tc(_tc), sys(tc->getSystemPtr()), pcbb(_pcbb) + { + + } + ~ThreadInfo() + {} + + inline Addr + curThreadInfo() + { + if (!TheISA::CurThreadInfoImplemented) + panic("curThreadInfo() not implemented for this ISA"); + + Addr addr = pcbb; + Addr sp; + + if (!addr) + addr = tc->readMiscRegNoEffect(TheISA::CurThreadInfoReg); + + PortProxy &p = tc->getPhysProxy(); + p.readBlob(addr, (uint8_t *)&sp, sizeof(Addr)); + + return sp & ~ULL(0x3fff); + } + + inline Addr + curTaskInfo(Addr thread_info = 0) + { + int32_t offset; + if (!get_data("thread_info_task", offset)) + return 0; + + if (!thread_info) + thread_info = curThreadInfo(); + + Addr addr; + CopyOut(tc, &addr, thread_info + offset, sizeof(addr)); + + return addr; + } + + int32_t + curTaskPID(Addr thread_info = 0) + { + int32_t offset; + if (!get_data("task_struct_pid", offset)) + return -1; + + int32_t pid; + CopyOut(tc, &pid, curTaskInfo(thread_info) + offset, sizeof(pid)); + + return pid; + } + + int32_t + curTaskTGID(Addr thread_info = 0) + { + int32_t offset; + if (!get_data("task_struct_tgid", offset)) + return -1; + + int32_t tgid; + CopyOut(tc, &tgid, curTaskInfo(thread_info) + offset, sizeof(tgid)); + + return tgid; + } + + int64_t + curTaskStart(Addr thread_info = 0) + { + int32_t offset; + if (!get_data("task_struct_start_time", offset)) + return -1; + + int64_t data; + // start_time is actually of type timespec, but if we just + // grab the first long, we'll get the seconds out of it + CopyOut(tc, &data, curTaskInfo(thread_info) + offset, sizeof(data)); + + return data; + } + + std::string + curTaskName(Addr thread_info = 0) + { + int32_t offset; + int32_t size; + + if (!get_data("task_struct_comm", offset)) + return "FailureIn_curTaskName"; + + if (!get_data("task_struct_comm_size", size)) + return "FailureIn_curTaskName"; + + char buffer[size + 1]; + CopyStringOut(tc, buffer, curTaskInfo(thread_info) + offset, size); + + return buffer; + } + + int32_t + curTaskMm(Addr thread_info = 0) + { + int32_t offset; + if (!get_data("task_struct_mm", offset)) + return -1; + + int32_t mm_ptr; + CopyOut(tc, &mm_ptr, curTaskInfo(thread_info) + offset, sizeof(mm_ptr)); + + return mm_ptr; + } +}; + +} // namespace FreeBSD + +#endif // __ARCH_GENERIC_FREEBSD_THREADINFO_HH__ diff -r 74e3c7359393 src/base/loader/elf_object.cc --- a/src/base/loader/elf_object.cc Wed Apr 22 20:22:29 2015 -0700 +++ b/src/base/loader/elf_object.cc Thu Apr 23 16:22:41 2015 +0100 @@ -150,6 +150,9 @@ case ELFOSABI_ARM: opSys = ObjectFile::LinuxArmOABI; break; + case ELFOSABI_FREEBSD: + opSys = ObjectFile::FreeBSD; + break; default: opSys = ObjectFile::UnknownOpSys; } @@ -160,7 +163,8 @@ Elf_Scn *section; GElf_Shdr shdr; Elf_Data *data; - uint32_t osAbi;; + uint32_t osAbi; + uint32_t *elem; int secIdx = 1; // Get the first section @@ -194,6 +198,16 @@ opSys = ObjectFile::Solaris; if (!strcmp(".stab.index", elf_strptr(elf, ehdr.e_shstrndx, shdr.sh_name))) opSys = ObjectFile::Solaris; + if (shdr.sh_type == SHT_NOTE && !strcmp(".note.tag", + elf_strptr(elf, ehdr.e_shstrndx, shdr.sh_name))) { + data = elf_rawdata(section, NULL); + assert(data->d_buf); + elem = (uint32_t *)data->d_buf; + if (elem[0] == 0x8) { //size of name + if (memcmp((void *)&elem[3], "FreeBSD", 0x8) == 0) + opSys = ObjectFile::FreeBSD; + } + } section = elf_getscn(elf, ++secIdx); } // while sections diff -r 74e3c7359393 src/base/loader/object_file.hh --- a/src/base/loader/object_file.hh Wed Apr 22 20:22:29 2015 -0700 +++ b/src/base/loader/object_file.hh Thu Apr 23 16:22:41 2015 +0100 @@ -63,7 +63,8 @@ Tru64, Linux, Solaris, - LinuxArmOABI + LinuxArmOABI, + FreeBSD }; protected: diff -r 74e3c7359393 src/base/output.cc --- a/src/base/output.cc Wed Apr 22 20:22:29 2015 -0700 +++ b/src/base/output.cc Thu Apr 23 16:22:41 2015 +0100 @@ -32,6 +32,7 @@ #include #include #include +#include #include #include diff -r 74e3c7359393 src/arch/arm/system.hh --- a/src/arch/arm/system.hh Wed Apr 22 20:22:29 2015 -0700 +++ b/src/arch/arm/system.hh Thu Apr 23 16:22:41 2015 +0100 @@ -49,6 +49,7 @@ #include "dev/arm/generic_timer.hh" #include "kern/linux/events.hh" #include "params/ArmSystem.hh" +#include "params/GenericArmSystem.hh" #include "sim/sim_object.hh" #include "sim/system.hh" @@ -265,7 +266,25 @@ /** Returns true if ASID is 16 bits for the system of a specific thread * context while in AArch64 (ARMv8) */ static bool haveLargeAsid64(ThreadContext *tc); +}; +class GenericArmSystem : public ArmSystem +{ + public: + typedef GenericArmSystemParams Params; + const Params * + params() const + { + return dynamic_cast(_params); + } + + GenericArmSystem(Params *p); + ~GenericArmSystem(); + + /** + * Initialise the system + */ + virtual void initState(); }; #endif diff -r 74e3c7359393 src/arch/arm/system.cc --- a/src/arch/arm/system.cc Wed Apr 22 20:22:29 2015 -0700 +++ b/src/arch/arm/system.cc Thu Apr 23 16:22:41 2015 +0100 @@ -244,8 +244,38 @@ { return dynamic_cast(tc->getSystemPtr())->haveLargeAsid64(); } + ArmSystem * ArmSystemParams::create() { return new ArmSystem(this); } + +GenericArmSystem::GenericArmSystem(Params *p) + : ArmSystem(p) +{ + +} + +GenericArmSystem::~GenericArmSystem() +{ + +} + +void +GenericArmSystem::initState() +{ + // Moved from the constructor to here since it relies on the + // address map being resolved in the interconnect + + // Call the initialisation of the super class + ArmSystem::initState(); + + //const Params* p = params(); +} + +GenericArmSystem * +GenericArmSystemParams::create() +{ + return new GenericArmSystem(this); +} diff -r 74e3c7359393 src/arch/arm/process.cc --- a/src/arch/arm/process.cc Wed Apr 22 20:22:29 2015 -0700 +++ b/src/arch/arm/process.cc Thu Apr 23 16:22:41 2015 +0100 @@ -199,13 +199,19 @@ Arm_Vfpv3d16 | 0; - //Bits which describe the system hardware capabilities - //XXX Figure out what these should be - auxv.push_back(auxv_t(M5_AT_HWCAP, features)); + if (objFile->getOpSys() == ObjectFile::Linux) { + //Bits which describe the system hardware capabilities + //XXX Figure out what these should be + auxv.push_back(auxv_t(M5_AT_HWCAP, features)); + } + //The system page size auxv.push_back(auxv_t(M5_AT_PAGESZ, ArmISA::PageBytes)); - //Frequency at which times() increments - auxv.push_back(auxv_t(M5_AT_CLKTCK, 0x64)); + if (objFile->getOpSys() == ObjectFile::Linux) { + //Frequency at which times() increments + auxv.push_back(auxv_t(M5_AT_CLKTCK, 0x64)); + } + // For statically linked executables, this is the virtual address of the // program header tables if they appear in the executable image auxv.push_back(auxv_t(M5_AT_PHDR, elfObject->programHeaderTable())); @@ -227,16 +233,19 @@ auxv.push_back(auxv_t(M5_AT_EUID, euid())); auxv.push_back(auxv_t(M5_AT_GID, gid())); auxv.push_back(auxv_t(M5_AT_EGID, egid())); - //Whether to enable "secure mode" in the executable - auxv.push_back(auxv_t(M5_AT_SECURE, 0)); - // Pointer to 16 bytes of random data - auxv.push_back(auxv_t(M5_AT_RANDOM, 0)); + if (objFile->getOpSys() == ObjectFile::Linux) { + //Whether to enable "secure mode" in the executable + auxv.push_back(auxv_t(M5_AT_SECURE, 0)); - //The filename of the program - auxv.push_back(auxv_t(M5_AT_EXECFN, 0)); - //The string "v71" -- ARM v7 architecture - auxv.push_back(auxv_t(M5_AT_PLATFORM, 0)); + // Pointer to 16 bytes of random data + auxv.push_back(auxv_t(M5_AT_RANDOM, 0)); + + //The filename of the program + auxv.push_back(auxv_t(M5_AT_EXECFN, 0)); + //The string "v71" -- ARM v7 architecture + auxv.push_back(auxv_t(M5_AT_PLATFORM, 0)); + } } //Figure out how big the initial stack nedes to be @@ -456,11 +465,33 @@ void ArmLiveProcess32::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret) { + + if (objFile->getOpSys() == ObjectFile::FreeBSD) { + // Decode return value + if (sysret.encodedValue() >= 0) + // FreeBSD checks the carry bit to determine if syscall is succeeded + tc->setCCReg(CCREG_C, 0); + else { + sysret = -sysret.encodedValue(); + } + } + tc->setIntReg(ReturnValueReg, sysret.encodedValue()); } void ArmLiveProcess64::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret) { + + if (objFile->getOpSys() == ObjectFile::FreeBSD) { + // Decode return value + if (sysret.encodedValue() >= 0) + // FreeBSD checks the carry bit to determine if syscall is succeeded + tc->setCCReg(CCREG_C, 0); + else { + sysret = -sysret.encodedValue(); + } + } + tc->setIntReg(ReturnValueReg, sysret.encodedValue()); } diff -r 74e3c7359393 src/arch/arm/linux/system.cc --- a/src/arch/arm/linux/system.cc Wed Apr 22 20:22:29 2015 -0700 +++ b/src/arch/arm/linux/system.cc Thu Apr 23 16:22:41 2015 +0100 @@ -61,7 +61,7 @@ using namespace Linux; LinuxArmSystem::LinuxArmSystem(Params *p) - : ArmSystem(p), dumpStatsPCEvent(nullptr), + : GenericArmSystem(p), dumpStatsPCEvent(nullptr), enableContextSwitchStatsDump(p->enable_context_switch_stats_dump), taskFile(nullptr), kernelPanicEvent(nullptr), kernelOopsEvent(nullptr), bootReleaseAddr(p->boot_release_addr) @@ -133,7 +133,7 @@ // address map being resolved in the interconnect // Call the initialisation of the super class - ArmSystem::initState(); + GenericArmSystem::initState(); // Load symbols at physical address, we might not want // to do this permanently, for but early bootup work diff -r 74e3c7359393 src/arch/arm/freebsd/system.hh --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/arch/arm/freebsd/system.hh Thu Apr 23 16:22:41 2015 +0100 @@ -0,0 +1,134 @@ +/*- + * Copyright (c) 2015 Ruslan Bukin + * All rights reserved. + * + * This software was developed by the University of Cambridge Computer + * Laboratory as part of the CTSRD Project, with support from the UK Higher + * Education Innovation Fund (HEIF). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 __ARCH_ARM_FREEBSD_SYSTEM_HH__ +#define __ARCH_ARM_FREEBSD_SYSTEM_HH__ + +#include +#include +#include +#include + +#include "arch/arm/system.hh" +#include "base/output.hh" +#include "kern/freebsd/events.hh" +#include "params/FreebsdArmSystem.hh" +#include "sim/core.hh" + +class DumpStatsPCEventF; + +class FreebsdArmSystem : public GenericArmSystem +{ + protected: + DumpStatsPCEventF *dumpStatsPCEventF; + + public: + /** Boilerplate params code */ + typedef FreebsdArmSystemParams Params; + const Params * + params() const + { + return dynamic_cast(_params); + } + + /** When enabled, dump stats/task info on context switches for + * Streamline and per-thread cache occupancy studies, etc. */ + bool enableContextSwitchStatsDump; + + /** This map stores a mapping of OS process IDs to internal Task IDs. The + * mapping is done because the stats system doesn't tend to like vectors + * that are much greater than 1000 items and the entire process space is + * 65K. */ + std::map taskMap; + + /** This is a file that is placed in the run directory that prints out + * mappings between taskIds and OS process IDs */ + std::ostream* taskFile; + + FreebsdArmSystem(Params *p); + ~FreebsdArmSystem(); + + void initState(); + + bool adderBootUncacheable(Addr a); + + void startup(); + + /** This function creates a new task Id for the given pid. + * @param tc thread context that is currentyl executing */ + void mapPid(ThreadContext* tc, uint32_t pid); + + private: + /** Event to halt the simulator if the kernel calls panic() */ + PCEvent *kernelPanicEvent; + + /** Event to halt the simulator if the kernel calls oopses */ + PCEvent *kernelOopsEvent; + + /** + * PC based event to skip udelay(