From 109908c2a6322d1fa31c0b486ea2bada14a292b8 Mon Sep 17 00:00:00 2001 From: Steve Reinhardt Date: Mon, 12 May 2014 14:23:31 -0700 Subject: syscall emulation: clean up & comment SyscallReturn --- src/arch/alpha/process.cc | 9 +++---- src/arch/arm/process.cc | 10 +++---- src/arch/mips/process.cc | 9 +++---- src/arch/power/process.cc | 7 +++-- src/arch/sparc/process.cc | 13 +++++---- src/arch/x86/process.cc | 4 +-- src/sim/syscall_emul.cc | 10 +++---- src/sim/syscallreturn.hh | 69 ++++++++++++++++++++++++++++++++++------------- 8 files changed, 79 insertions(+), 52 deletions(-) (limited to 'src') diff --git a/src/arch/alpha/process.cc b/src/arch/alpha/process.cc index 07208fb29..8cc83b0fd 100644 --- a/src/arch/alpha/process.cc +++ b/src/arch/alpha/process.cc @@ -220,19 +220,18 @@ AlphaLiveProcess::setSyscallArg(ThreadContext *tc, } void -AlphaLiveProcess::setSyscallReturn(ThreadContext *tc, - SyscallReturn return_value) +AlphaLiveProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret) { // check for error condition. Alpha syscall convention is to // indicate success/failure in reg a3 (r19) and put the // return value itself in the standard return value reg (v0). - if (return_value.successful()) { + if (sysret.successful()) { // no error tc->setIntReg(SyscallSuccessReg, 0); - tc->setIntReg(ReturnValueReg, return_value.value()); + tc->setIntReg(ReturnValueReg, sysret.returnValue()); } else { // got an error, return details tc->setIntReg(SyscallSuccessReg, (IntReg)-1); - tc->setIntReg(ReturnValueReg, -return_value.value()); + tc->setIntReg(ReturnValueReg, sysret.errnoValue()); } } diff --git a/src/arch/arm/process.cc b/src/arch/arm/process.cc index dd23a5e21..175382b43 100644 --- a/src/arch/arm/process.cc +++ b/src/arch/arm/process.cc @@ -454,15 +454,13 @@ ArmLiveProcess64::setSyscallArg(ThreadContext *tc, } void -ArmLiveProcess32::setSyscallReturn(ThreadContext *tc, - SyscallReturn return_value) +ArmLiveProcess32::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret) { - tc->setIntReg(ReturnValueReg, return_value.value()); + tc->setIntReg(ReturnValueReg, sysret.encodedValue()); } void -ArmLiveProcess64::setSyscallReturn(ThreadContext *tc, - SyscallReturn return_value) +ArmLiveProcess64::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret) { - tc->setIntReg(ReturnValueReg, return_value.value()); + tc->setIntReg(ReturnValueReg, sysret.encodedValue()); } diff --git a/src/arch/mips/process.cc b/src/arch/mips/process.cc index 4ed9a7b39..f84c5cc4a 100644 --- a/src/arch/mips/process.cc +++ b/src/arch/mips/process.cc @@ -197,16 +197,15 @@ MipsLiveProcess::setSyscallArg(ThreadContext *tc, } void -MipsLiveProcess::setSyscallReturn(ThreadContext *tc, - SyscallReturn return_value) +MipsLiveProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret) { - if (return_value.successful()) { + if (sysret.successful()) { // no error tc->setIntReg(SyscallSuccessReg, 0); - tc->setIntReg(ReturnValueReg, return_value.value()); + tc->setIntReg(ReturnValueReg, sysret.returnValue()); } else { // got an error, return details tc->setIntReg(SyscallSuccessReg, (IntReg) -1); - tc->setIntReg(ReturnValueReg, -return_value.value()); + tc->setIntReg(ReturnValueReg, sysret.errnoValue()); } } diff --git a/src/arch/power/process.cc b/src/arch/power/process.cc index 3c5d1e8b4..175a84f6b 100644 --- a/src/arch/power/process.cc +++ b/src/arch/power/process.cc @@ -277,15 +277,14 @@ PowerLiveProcess::setSyscallArg(ThreadContext *tc, } void -PowerLiveProcess::setSyscallReturn(ThreadContext *tc, - SyscallReturn return_value) +PowerLiveProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret) { Cr cr = tc->readIntReg(INTREG_CR); - if (return_value.successful()) { + if (sysret.successful()) { cr.cr0.so = 0; } else { cr.cr0.so = 1; } tc->setIntReg(INTREG_CR, cr); - tc->setIntReg(ReturnValueReg, return_value.value()); + tc->setIntReg(ReturnValueReg, sysret.encodedValue()); } diff --git a/src/arch/sparc/process.cc b/src/arch/sparc/process.cc index 456b8b94a..06b0d18b3 100644 --- a/src/arch/sparc/process.cc +++ b/src/arch/sparc/process.cc @@ -532,26 +532,25 @@ Sparc64LiveProcess::setSyscallArg(ThreadContext *tc, int i, IntReg val) } void -SparcLiveProcess::setSyscallReturn(ThreadContext *tc, - SyscallReturn return_value) +SparcLiveProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret) { // check for error condition. SPARC syscall convention is to // indicate success/failure in reg the carry bit of the ccr // and put the return value itself in the standard return value reg (). PSTATE pstate = tc->readMiscRegNoEffect(MISCREG_PSTATE); - if (return_value.successful()) { + if (sysret.successful()) { // no error, clear XCC.C tc->setIntReg(NumIntArchRegs + 2, - tc->readIntReg(NumIntArchRegs + 2) & 0xEE); - IntReg val = return_value.value(); + tc->readIntReg(NumIntArchRegs + 2) & 0xEE); + IntReg val = sysret.returnValue(); if (pstate.am) val = bits(val, 31, 0); tc->setIntReg(ReturnValueReg, val); } else { // got an error, set XCC.C tc->setIntReg(NumIntArchRegs + 2, - tc->readIntReg(NumIntArchRegs + 2) | 0x11); - IntReg val = -return_value.value(); + tc->readIntReg(NumIntArchRegs + 2) | 0x11); + IntReg val = sysret.errnoValue(); if (pstate.am) val = bits(val, 31, 0); tc->setIntReg(ReturnValueReg, val); diff --git a/src/arch/x86/process.cc b/src/arch/x86/process.cc index bf7669cdf..95a7f9998 100644 --- a/src/arch/x86/process.cc +++ b/src/arch/x86/process.cc @@ -678,9 +678,9 @@ I386LiveProcess::argsInit(int intSize, int pageSize) } void -X86LiveProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn return_value) +X86LiveProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn retval) { - tc->setIntReg(INTREG_RAX, return_value.value()); + tc->setIntReg(INTREG_RAX, retval.encodedValue()); } X86ISA::IntReg diff --git a/src/sim/syscall_emul.cc b/src/sim/syscall_emul.cc index 935193e7f..61ba32955 100644 --- a/src/sim/syscall_emul.cc +++ b/src/sim/syscall_emul.cc @@ -69,7 +69,7 @@ SyscallDesc::doSyscall(int callnum, LiveProcess *process, ThreadContext *tc) SyscallReturn retval = (*funcPtr)(this, callnum, process, tc); DPRINTFR(SyscallVerbose, "%d: %s: syscall %s returns %d\n", - curTick(),tc->getCpuPtr()->name(), name, retval.value()); + curTick(), tc->getCpuPtr()->name(), name, retval.encodedValue()); if (!(flags & SyscallDesc::SuppressReturnValue)) process->setSyscallReturn(tc, retval); @@ -366,7 +366,7 @@ readlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc, string path; if (!tc->getMemProxy().tryReadString(path, p->getSyscallArg(tc, index))) - return (TheISA::IntReg)-EFAULT; + return -EFAULT; // Adjust path for current working directory path = p->fullPath(path); @@ -390,7 +390,7 @@ unlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) int index = 0; if (!tc->getMemProxy().tryReadString(path, p->getSyscallArg(tc, index))) - return (TheISA::IntReg)-EFAULT; + return -EFAULT; // Adjust path for current working directory path = p->fullPath(path); @@ -407,7 +407,7 @@ mkdirFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) int index = 0; if (!tc->getMemProxy().tryReadString(path, p->getSyscallArg(tc, index))) - return (TheISA::IntReg)-EFAULT; + return -EFAULT; // Adjust path for current working directory path = p->fullPath(path); @@ -864,7 +864,7 @@ accessFunc(SyscallDesc *desc, int callnum, LiveProcess *p, ThreadContext *tc, { string path; if (!tc->getMemProxy().tryReadString(path, p->getSyscallArg(tc, index))) - return (TheISA::IntReg)-EFAULT; + return -EFAULT; // Adjust path for current working directory path = p->fullPath(path); diff --git a/src/sim/syscallreturn.hh b/src/sim/syscallreturn.hh index 385ff55db..547d76610 100644 --- a/src/sim/syscallreturn.hh +++ b/src/sim/syscallreturn.hh @@ -33,38 +33,71 @@ #include "base/types.hh" +/** + * This class represents the return value from an emulated system call, + * including any errno setting. + * + * On some platforms, the return value and errno are encoded in a + * single signed integer. A value less than zero but greater than + * -4096 indicates an error, and the value is the negation of the + * errno value. Otherwise, the call was successful and the integer is + * the return value. (Large negative numbers are considered + * successful to allow syscalls to return pointers to high memory, + * e.g., stack addresses.) See, for example, Appendix A of the AMD64 + * ABI spec at http://www.x86-64.org/documentation/abi.pdf. + * + * Other platforms use a more complex interface, returning a value and + * an error code in separate registers. + * + * This class is designed to support both types of interfaces. + */ class SyscallReturn { public: - template - SyscallReturn(T v, bool s) + + /// For simplicity, allow the object to be initialized with a + /// single signed integer using the same positive=success, + /// negative=-errno convention described above. + /// + /// Typically this constructor is used as a default type + /// conversion, so a bare integer is used where a SyscallReturn + /// value is expected, e.g., as the return value from a system + /// call emulation function ('return 0;' or 'return -EFAULT;'). + SyscallReturn(int64_t v) + : value(v) + {} + + ~SyscallReturn() {} + + /// Was the system call successful? + bool successful() const { - retval = (uint64_t)v; - success = s; + return (value >= 0 || value <= -4096); } - template - SyscallReturn(T v) + /// The return value + int64_t returnValue() const { - success = (v >= 0); - retval = (uint64_t)v; + assert(successful()); + return value; } - ~SyscallReturn() {} + /// The errno value + int errnoValue() const + { + assert(!successful()); + return -value; + } - SyscallReturn& operator=(const SyscallReturn& s) + /// The encoded value (as described above) + int64_t encodedValue() const { - retval = s.retval; - success = s.success; - return *this; + return value; } - bool successful() { return success; } - uint64_t value() { return retval; } + private: - private: - uint64_t retval; - bool success; + int64_t value; }; #endif -- cgit v1.2.3