sanchayanmaity/gem5
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Syscalls: Make system calls access arguments like a stack, not an array.

Browse source 
When accessing arguments for a syscall, the position of an argument depends on
the policies of the ISA, how much space preceding arguments took up, and the
"alignment" of the index for this particular argument into the number of
possible storate locations. This change adjusts getSyscallArg to take its
index parameter by reference instead of value and to adjust it to point to the
possible location of the next argument on the stack, basically just after the
current one. This way, the rules for the new argument can be applied locally
without knowing about other arguments since those have already been taken into
account implicitly.

All system calls have also been changed to reflect the new interface. In a
number of cases this made the implementation clearer since it encourages
arguments to be collected in one place in order and then used as necessary
later, as opposed to scattering them throughout the function or using them in
place in long expressions. It also discourages using getSyscallArg over and
over to retrieve the same value when a temporary would do the job.
This commit is contained in:
Gabe Black 2009-10-30 00:44:55 -07:00
parent 25d9328689
commit 3f722b991f
27 changed files with 361 additions and 229 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
src/arch/alpha/linux/process.cc
View file

@ -48,7 +48,8 @@ static SyscallReturn
unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process, unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
TypedBufferArg<Linux::utsname> name(process->getSyscallArg(tc, 0)); int index = 0;
TypedBufferArg<Linux::utsname> name(process->getSyscallArg(tc, index));
strcpy(name->sysname, "Linux"); strcpy(name->sysname, "Linux");
strcpy(name->nodename, "m5.eecs.umich.edu"); strcpy(name->nodename, "m5.eecs.umich.edu");
@ -67,13 +68,15 @@ static SyscallReturn
osf_getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process, osf_getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
unsigned op = process->getSyscallArg(tc, 0); int index = 0;
unsigned op = process->getSyscallArg(tc, index);
Addr bufPtr = process->getSyscallArg(tc, index);
// unsigned nbytes = process->getSyscallArg(tc, 2); // unsigned nbytes = process->getSyscallArg(tc, 2);
switch (op) { switch (op) {
case 45: { // GSI_IEEE_FP_CONTROL case 45: { // GSI_IEEE_FP_CONTROL
TypedBufferArg<uint64_t> fpcr(process->getSyscallArg(tc, 1)); TypedBufferArg<uint64_t> fpcr(bufPtr);
// I don't think this exactly matches the HW FPCR // I don't think this exactly matches the HW FPCR
*fpcr = 0; *fpcr = 0;
fpcr.copyOut(tc->getMemPort()); fpcr.copyOut(tc->getMemPort());
@ -94,13 +97,15 @@ static SyscallReturn
osf_setsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process, osf_setsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
unsigned op = process->getSyscallArg(tc, 0); int index = 0;
unsigned op = process->getSyscallArg(tc, index);
Addr bufPtr = process->getSyscallArg(tc, index);
// unsigned nbytes = process->getSyscallArg(tc, 2); // unsigned nbytes = process->getSyscallArg(tc, 2);
switch (op) { switch (op) {
case 14: { // SSI_IEEE_FP_CONTROL case 14: { // SSI_IEEE_FP_CONTROL
TypedBufferArg<uint64_t> fpcr(process->getSyscallArg(tc, 1)); TypedBufferArg<uint64_t> fpcr(bufPtr);
// I don't think this exactly matches the HW FPCR // I don't think this exactly matches the HW FPCR
fpcr.copyIn(tc->getMemPort()); fpcr.copyIn(tc->getMemPort());
DPRINTFR(SyscallVerbose, "osf_setsysinfo(SSI_IEEE_FP_CONTROL): " DPRINTFR(SyscallVerbose, "osf_setsysinfo(SSI_IEEE_FP_CONTROL): "

4
src/arch/alpha/process.cc
View file

@ -193,10 +193,10 @@ AlphaLiveProcess::startup()
} }
AlphaISA::IntReg AlphaISA::IntReg
AlphaLiveProcess::getSyscallArg(ThreadContext *tc, int i) AlphaLiveProcess::getSyscallArg(ThreadContext *tc, int &i)
{ {
assert(i < 6); assert(i < 6);
return tc->readIntReg(FirstArgumentReg + i); return tc->readIntReg(FirstArgumentReg + i++);
} }
void void

2
src/arch/alpha/process.hh
View file

@ -44,7 +44,7 @@ class AlphaLiveProcess : public LiveProcess
void argsInit(int intSize, int pageSize); void argsInit(int intSize, int pageSize);
public: public:
AlphaISA::IntReg getSyscallArg(ThreadContext *tc, int i); AlphaISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
void setSyscallArg(ThreadContext *tc, int i, AlphaISA::IntReg val); void setSyscallArg(ThreadContext *tc, int i, AlphaISA::IntReg val);
void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value); void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value);
}; };

41
src/arch/alpha/tru64/process.cc
View file

@ -45,7 +45,8 @@ static SyscallReturn
unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process, unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
TypedBufferArg<AlphaTru64::utsname> name(process->getSyscallArg(tc, 0)); int index = 0;
TypedBufferArg<AlphaTru64::utsname> name(process->getSyscallArg(tc, index));
strcpy(name->sysname, "OSF1"); strcpy(name->sysname, "OSF1");
strcpy(name->nodename, "m5.eecs.umich.edu"); strcpy(name->nodename, "m5.eecs.umich.edu");
@ -62,35 +63,36 @@ static SyscallReturn
getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process, getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
unsigned op = process->getSyscallArg(tc, 0); int index = 0;
unsigned nbytes = process->getSyscallArg(tc, 2); unsigned op = process->getSyscallArg(tc, index);
Addr bufPtr = process->getSyscallArg(tc, index);
unsigned nbytes = process->getSyscallArg(tc, index);
switch (op) { switch (op) {
case AlphaTru64::GSI_MAX_CPU: { case AlphaTru64::GSI_MAX_CPU: {
TypedBufferArg<uint32_t> max_cpu(process->getSyscallArg(tc, 1)); TypedBufferArg<uint32_t> max_cpu(bufPtr);
*max_cpu = htog((uint32_t)process->numCpus()); *max_cpu = htog((uint32_t)process->numCpus());
max_cpu.copyOut(tc->getMemPort()); max_cpu.copyOut(tc->getMemPort());
return 1; return 1;
} }
case AlphaTru64::GSI_CPUS_IN_BOX: { case AlphaTru64::GSI_CPUS_IN_BOX: {
TypedBufferArg<uint32_t> cpus_in_box(process->getSyscallArg(tc, 1)); TypedBufferArg<uint32_t> cpus_in_box(bufPtr);
*cpus_in_box = htog((uint32_t)process->numCpus()); *cpus_in_box = htog((uint32_t)process->numCpus());
cpus_in_box.copyOut(tc->getMemPort()); cpus_in_box.copyOut(tc->getMemPort());
return 1; return 1;
} }
case AlphaTru64::GSI_PHYSMEM: { case AlphaTru64::GSI_PHYSMEM: {
TypedBufferArg<uint64_t> physmem(process->getSyscallArg(tc, 1)); TypedBufferArg<uint64_t> physmem(bufPtr);
*physmem = htog((uint64_t)1024 * 1024); // physical memory in KB *physmem = htog((uint64_t)1024 * 1024); // physical memory in KB
physmem.copyOut(tc->getMemPort()); physmem.copyOut(tc->getMemPort());
return 1; return 1;
} }
case AlphaTru64::GSI_CPU_INFO: { case AlphaTru64::GSI_CPU_INFO: {
TypedBufferArg<AlphaTru64::cpu_info> TypedBufferArg<AlphaTru64::cpu_info> infop(bufPtr);
infop(process->getSyscallArg(tc, 1));
infop->current_cpu = htog(0); infop->current_cpu = htog(0);
infop->cpus_in_box = htog(process->numCpus()); infop->cpus_in_box = htog(process->numCpus());
@ -107,14 +109,14 @@ getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
} }
case AlphaTru64::GSI_PROC_TYPE: { case AlphaTru64::GSI_PROC_TYPE: {
TypedBufferArg<uint64_t> proc_type(process->getSyscallArg(tc, 1)); TypedBufferArg<uint64_t> proc_type(bufPtr);
*proc_type = htog((uint64_t)11); *proc_type = htog((uint64_t)11);
proc_type.copyOut(tc->getMemPort()); proc_type.copyOut(tc->getMemPort());
return 1; return 1;
} }
case AlphaTru64::GSI_PLATFORM_NAME: { case AlphaTru64::GSI_PLATFORM_NAME: {
BufferArg bufArg(process->getSyscallArg(tc, 1), nbytes); BufferArg bufArg(bufPtr, nbytes);
strncpy((char *)bufArg.bufferPtr(), strncpy((char *)bufArg.bufferPtr(),
"COMPAQ Professional Workstation XP1000", "COMPAQ Professional Workstation XP1000",
nbytes); nbytes);
@ -123,7 +125,7 @@ getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
} }
case AlphaTru64::GSI_CLK_TCK: { case AlphaTru64::GSI_CLK_TCK: {
TypedBufferArg<uint64_t> clk_hz(process->getSyscallArg(tc, 1)); TypedBufferArg<uint64_t> clk_hz(bufPtr);
*clk_hz = htog((uint64_t)1024); *clk_hz = htog((uint64_t)1024);
clk_hz.copyOut(tc->getMemPort()); clk_hz.copyOut(tc->getMemPort());
return 1; return 1;
@ -142,12 +144,13 @@ static SyscallReturn
setsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process, setsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
unsigned op = process->getSyscallArg(tc, 0); int index = 0;
unsigned op = process->getSyscallArg(tc, index);
switch (op) { switch (op) {
case AlphaTru64::SSI_IEEE_FP_CONTROL: case AlphaTru64::SSI_IEEE_FP_CONTROL:
warn("setsysinfo: ignoring ieee_set_fp_control() arg 0x%x\n", warn("setsysinfo: ignoring ieee_set_fp_control() arg 0x%x\n",
process->getSyscallArg(tc, 1)); process->getSyscallArg(tc, index));
break; break;
default: default:
@ -165,17 +168,19 @@ tableFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
{ {
using namespace std; using namespace std;
int id = process->getSyscallArg(tc, 0); // table ID int argIndex = 0;
int index = process->getSyscallArg(tc, 1); // index into table int id = process->getSyscallArg(tc, argIndex); // table ID
int index = process->getSyscallArg(tc, argIndex); // index into table
Addr bufPtr = process->getSyscallArg(tc, argIndex);
// arg 2 is buffer pointer; type depends on table ID // arg 2 is buffer pointer; type depends on table ID
int nel = process->getSyscallArg(tc, 3); // number of elements int nel = process->getSyscallArg(tc, argIndex); // number of elements
int lel = process->getSyscallArg(tc, 4); // expected element size int lel = process->getSyscallArg(tc, argIndex); // expected element size
switch (id) { switch (id) {
case AlphaTru64::TBL_SYSINFO: { case AlphaTru64::TBL_SYSINFO: {
if (index != 0 || nel != 1 || lel != sizeof(Tru64::tbl_sysinfo)) if (index != 0 || nel != 1 || lel != sizeof(Tru64::tbl_sysinfo))
return -EINVAL; return -EINVAL;
TypedBufferArg<Tru64::tbl_sysinfo> elp(process->getSyscallArg(tc, 2)); TypedBufferArg<Tru64::tbl_sysinfo> elp(bufPtr);
const int clk_hz = one_million; const int clk_hz = one_million;
elp->si_user = htog(curTick / (Clock::Frequency / clk_hz)); elp->si_user = htog(curTick / (Clock::Frequency / clk_hz));

10
src/arch/arm/linux/process.cc
View file

@ -50,7 +50,8 @@ static SyscallReturn
unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process, unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
TypedBufferArg<Linux::utsname> name(process->getSyscallArg(tc, 0)); int index = 0;
TypedBufferArg<Linux::utsname> name(process->getSyscallArg(tc, index));
strcpy(name->sysname, "Linux"); strcpy(name->sysname, "Linux");
strcpy(name->nodename, "m5.eecs.umich.edu"); strcpy(name->nodename, "m5.eecs.umich.edu");
@ -417,7 +418,8 @@ static SyscallReturn
setTLSFunc(SyscallDesc *desc, int callnum, LiveProcess *process, setTLSFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
uint32_t tlsPtr = process->getSyscallArg(tc, 0); int index = 0;
uint32_t tlsPtr = process->getSyscallArg(tc, index);
tc->getMemPort()->writeBlob(ArmLinuxProcess::commPage + 0x0ff0, tc->getMemPort()->writeBlob(ArmLinuxProcess::commPage + 0x0ff0,
(uint8_t *)&tlsPtr, sizeof(tlsPtr)); (uint8_t *)&tlsPtr, sizeof(tlsPtr));
@ -511,12 +513,12 @@ ArmLinuxProcess::startup()
} }
ArmISA::IntReg ArmISA::IntReg
ArmLinuxProcess::getSyscallArg(ThreadContext *tc, int i) ArmLinuxProcess::getSyscallArg(ThreadContext *tc, int &i)
{ {
// Linux apparently allows more parameter than the ABI says it should. // Linux apparently allows more parameter than the ABI says it should.
// This limit may need to be increased even further. // This limit may need to be increased even further.
assert(i < 6); assert(i < 6);
return tc->readIntReg(ArgumentReg0 + i); return tc->readIntReg(ArgumentReg0 + i++);
} }
void void

2
src/arch/arm/linux/process.hh
View file

@ -44,7 +44,7 @@ class ArmLinuxProcess : public ArmLiveProcess
void startup(); void startup();
ArmISA::IntReg getSyscallArg(ThreadContext *tc, int i); ArmISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
void setSyscallArg(ThreadContext *tc, int i, ArmISA::IntReg val); void setSyscallArg(ThreadContext *tc, int i, ArmISA::IntReg val);
/// The target system's hostname. /// The target system's hostname.

4
src/arch/arm/process.cc
View file

@ -324,10 +324,10 @@ ArmLiveProcess::argsInit(int intSize, int pageSize)
} }
ArmISA::IntReg ArmISA::IntReg
ArmLiveProcess::getSyscallArg(ThreadContext *tc, int i) ArmLiveProcess::getSyscallArg(ThreadContext *tc, int &i)
{ {
assert(i < 4); assert(i < 4);
return tc->readIntReg(ArgumentReg0 + i); return tc->readIntReg(ArgumentReg0 + i++);
} }
void void

2
src/arch/arm/process.hh
View file

@ -53,7 +53,7 @@ class ArmLiveProcess : public LiveProcess
public: public:
void argsInit(int intSize, int pageSize); void argsInit(int intSize, int pageSize);
ArmISA::IntReg getSyscallArg(ThreadContext *tc, int i); ArmISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
void setSyscallArg(ThreadContext *tc, int i, ArmISA::IntReg val); void setSyscallArg(ThreadContext *tc, int i, ArmISA::IntReg val);
void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value); void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value);
}; };

19
src/arch/mips/linux/process.cc
View file

@ -51,7 +51,8 @@ static SyscallReturn
unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process, unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
TypedBufferArg<Linux::utsname> name(process->getSyscallArg(tc, 0)); int index = 0;
TypedBufferArg<Linux::utsname> name(process->getSyscallArg(tc, index));
strcpy(name->sysname, "Linux"); strcpy(name->sysname, "Linux");
strcpy(name->nodename,"m5.eecs.umich.edu"); strcpy(name->nodename,"m5.eecs.umich.edu");
@ -70,14 +71,16 @@ static SyscallReturn
sys_getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process, sys_getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
unsigned op = process->getSyscallArg(tc, 0); int index = 0;
// unsigned nbytes = process->getSyscallArg(tc, 2); unsigned op = process->getSyscallArg(tc, index);
unsigned bufPtr = process->getSyscallArg(tc, index);
// unsigned nbytes = process->getSyscallArg(tc, index);
switch (op) { switch (op) {
case 45: case 45:
{ {
// GSI_IEEE_FP_CONTROL // GSI_IEEE_FP_CONTROL
TypedBufferArg<uint64_t> fpcr(process->getSyscallArg(tc, 1)); TypedBufferArg<uint64_t> fpcr(bufPtr);
// I don't think this exactly matches the HW FPCR // I don't think this exactly matches the HW FPCR
*fpcr = 0; *fpcr = 0;
fpcr.copyOut(tc->getMemPort()); fpcr.copyOut(tc->getMemPort());
@ -97,15 +100,17 @@ static SyscallReturn
sys_setsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process, sys_setsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
unsigned op = process->getSyscallArg(tc, 0); int index = 0;
// unsigned nbytes = process->getSyscallArg(tc, 2); unsigned op = process->getSyscallArg(tc, index);
Addr bufPtr = process->getSyscallArg(tc, index);
// unsigned nbytes = process->getSyscallArg(tc, index);
switch (op) { switch (op) {
case 14: case 14:
{ {
// SSI_IEEE_FP_CONTROL // SSI_IEEE_FP_CONTROL
TypedBufferArg<uint64_t> fpcr(process->getSyscallArg(tc, 1)); TypedBufferArg<uint64_t> fpcr(bufPtr);
// I don't think this exactly matches the HW FPCR // I don't think this exactly matches the HW FPCR
fpcr.copyIn(tc->getMemPort()); fpcr.copyIn(tc->getMemPort());
DPRINTFR(SyscallVerbose, "sys_setsysinfo(SSI_IEEE_FP_CONTROL): " DPRINTFR(SyscallVerbose, "sys_setsysinfo(SSI_IEEE_FP_CONTROL): "

4
src/arch/mips/process.cc
View file

@ -147,10 +147,10 @@ MipsLiveProcess::argsInit(int intSize, int pageSize)
MipsISA::IntReg MipsISA::IntReg
MipsLiveProcess::getSyscallArg(ThreadContext *tc, int i) MipsLiveProcess::getSyscallArg(ThreadContext *tc, int &i)
{ {
assert(i < 6); assert(i < 6);
return tc->readIntReg(FirstArgumentReg + i); return tc->readIntReg(FirstArgumentReg + i++);
} }
void void

2
src/arch/mips/process.hh
View file

@ -50,7 +50,7 @@ class MipsLiveProcess : public LiveProcess
void argsInit(int intSize, int pageSize); void argsInit(int intSize, int pageSize);
public: public:
MipsISA::IntReg getSyscallArg(ThreadContext *tc, int i); MipsISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
void setSyscallArg(ThreadContext *tc, int i, MipsISA::IntReg val); void setSyscallArg(ThreadContext *tc, int i, MipsISA::IntReg val);
void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value); void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value);
}; };

7
src/arch/power/linux/process.cc
View file

@ -52,7 +52,8 @@ static SyscallReturn
unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process, unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
TypedBufferArg<Linux::utsname> name(process->getSyscallArg(tc, 0)); int index = 0;
TypedBufferArg<Linux::utsname> name(process->getSyscallArg(tc, index));
strcpy(name->sysname, "Linux"); strcpy(name->sysname, "Linux");
strcpy(name->nodename, "m5.eecs.umich.edu"); strcpy(name->nodename, "m5.eecs.umich.edu");
@ -437,12 +438,12 @@ PowerLinuxProcess::startup()
} }
PowerISA::IntReg PowerISA::IntReg
PowerLinuxProcess::getSyscallArg(ThreadContext *tc, int i) PowerLinuxProcess::getSyscallArg(ThreadContext *tc, int &i)
{ {
// Linux apparently allows more parameter than the ABI says it should. // Linux apparently allows more parameter than the ABI says it should.
// This limit may need to be increased even further. // This limit may need to be increased even further.
assert(i < 6); assert(i < 6);
return tc->readIntReg(ArgumentReg0 + i); return tc->readIntReg(ArgumentReg0 + i++);
} }
void void

2
src/arch/power/linux/process.hh
View file

@ -46,7 +46,7 @@ class PowerLinuxProcess : public PowerLiveProcess
void startup(); void startup();
PowerISA::IntReg getSyscallArg(ThreadContext *tc, int i); PowerISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
void setSyscallArg(ThreadContext *tc, int i, PowerISA::IntReg val); void setSyscallArg(ThreadContext *tc, int i, PowerISA::IntReg val);
/// Array of syscall descriptors, indexed by call number. /// Array of syscall descriptors, indexed by call number.

4
src/arch/power/process.cc
View file

@ -266,10 +266,10 @@ PowerLiveProcess::argsInit(int intSize, int pageSize)
} }
PowerISA::IntReg PowerISA::IntReg
PowerLiveProcess::getSyscallArg(ThreadContext *tc, int i) PowerLiveProcess::getSyscallArg(ThreadContext *tc, int &i)
{ {
assert(i < 5); assert(i < 5);
return tc->readIntReg(ArgumentReg0 + i); return tc->readIntReg(ArgumentReg0 + i++);
} }
void void

2
src/arch/power/process.hh
View file

@ -50,7 +50,7 @@ class PowerLiveProcess : public LiveProcess
public: public:
void argsInit(int intSize, int pageSize); void argsInit(int intSize, int pageSize);
PowerISA::IntReg getSyscallArg(ThreadContext *tc, int i); PowerISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
void setSyscallArg(ThreadContext *tc, int i, PowerISA::IntReg val); void setSyscallArg(ThreadContext *tc, int i, PowerISA::IntReg val);
void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value); void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value);
}; };

10
src/arch/sparc/linux/syscalls.cc
View file

@ -41,7 +41,8 @@ static SyscallReturn
unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process, unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
TypedBufferArg<Linux::utsname> name(process->getSyscallArg(tc, 0)); int index = 0;
TypedBufferArg<Linux::utsname> name(process->getSyscallArg(tc, index));
strcpy(name->sysname, "Linux"); strcpy(name->sysname, "Linux");
strcpy(name->nodename, "m5.eecs.umich.edu"); strcpy(name->nodename, "m5.eecs.umich.edu");
@ -59,9 +60,10 @@ SyscallReturn getresuidFunc(SyscallDesc *desc, int num,
LiveProcess *p, ThreadContext *tc) LiveProcess *p, ThreadContext *tc)
{ {
const IntReg id = htog(100); const IntReg id = htog(100);
Addr ruid = p->getSyscallArg(tc, 0); int index = 0;
Addr euid = p->getSyscallArg(tc, 1); Addr ruid = p->getSyscallArg(tc, index);
Addr suid = p->getSyscallArg(tc, 2); Addr euid = p->getSyscallArg(tc, index);
Addr suid = p->getSyscallArg(tc, index);
//Handle the EFAULT case //Handle the EFAULT case
//Set the ruid //Set the ruid
if(ruid) if(ruid)

8
src/arch/sparc/process.cc
View file

@ -514,10 +514,10 @@ void Sparc64LiveProcess::flushWindows(ThreadContext *tc)
} }
IntReg IntReg
Sparc32LiveProcess::getSyscallArg(ThreadContext *tc, int i) Sparc32LiveProcess::getSyscallArg(ThreadContext *tc, int &i)
{ {
assert(i < 6); assert(i < 6);
return bits(tc->readIntReg(FirstArgumentReg + i), 31, 0); return bits(tc->readIntReg(FirstArgumentReg + i++), 31, 0);
} }
void void
@ -528,10 +528,10 @@ Sparc32LiveProcess::setSyscallArg(ThreadContext *tc, int i, IntReg val)
} }
IntReg IntReg
Sparc64LiveProcess::getSyscallArg(ThreadContext *tc, int i) Sparc64LiveProcess::getSyscallArg(ThreadContext *tc, int &i)
{ {
assert(i < 6); assert(i < 6);
return tc->readIntReg(FirstArgumentReg + i); return tc->readIntReg(FirstArgumentReg + i++);
} }
void void

4
src/arch/sparc/process.hh
View file

@ -95,7 +95,7 @@ class Sparc32LiveProcess : public SparcLiveProcess
void flushWindows(ThreadContext *tc); void flushWindows(ThreadContext *tc);
SparcISA::IntReg getSyscallArg(ThreadContext *tc, int i); SparcISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
void setSyscallArg(ThreadContext *tc, int i, SparcISA::IntReg val); void setSyscallArg(ThreadContext *tc, int i, SparcISA::IntReg val);
}; };
@ -123,7 +123,7 @@ class Sparc64LiveProcess : public SparcLiveProcess
void flushWindows(ThreadContext *tc); void flushWindows(ThreadContext *tc);
SparcISA::IntReg getSyscallArg(ThreadContext *tc, int i); SparcISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
void setSyscallArg(ThreadContext *tc, int i, SparcISA::IntReg val); void setSyscallArg(ThreadContext *tc, int i, SparcISA::IntReg val);
}; };

3
src/arch/sparc/solaris/process.cc
View file

@ -48,7 +48,8 @@ static SyscallReturn
unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process, unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
TypedBufferArg<Solaris::utsname> name(process->getSyscallArg(tc, 0)); int index = 0;
TypedBufferArg<Solaris::utsname> name(process->getSyscallArg(tc, index));
strcpy(name->sysname, "SunOS"); strcpy(name->sysname, "SunOS");
strcpy(name->nodename, "m5.eecs.umich.edu"); strcpy(name->nodename, "m5.eecs.umich.edu");

11
src/arch/x86/linux/syscalls.cc
View file

@ -68,7 +68,8 @@ static SyscallReturn
unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process, unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
TypedBufferArg<Linux::utsname> name(process->getSyscallArg(tc, 0)); int index = 0;
TypedBufferArg<Linux::utsname> name(process->getSyscallArg(tc, index));
strcpy(name->sysname, "Linux"); strcpy(name->sysname, "Linux");
strcpy(name->nodename, "m5.eecs.umich.edu"); strcpy(name->nodename, "m5.eecs.umich.edu");
@ -94,8 +95,9 @@ archPrctlFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
}; };
//First argument is the code, second is the address //First argument is the code, second is the address
int code = process->getSyscallArg(tc, 0); int index = 0;
uint64_t addr = process->getSyscallArg(tc, 1); int code = process->getSyscallArg(tc, index);
uint64_t addr = process->getSyscallArg(tc, index);
uint64_t fsBase, gsBase; uint64_t fsBase, gsBase;
TranslatingPort *p = tc->getMemPort(); TranslatingPort *p = tc->getMemPort();
switch(code) switch(code)
@ -159,7 +161,8 @@ setThreadArea32Func(SyscallDesc *desc, int callnum,
assert((maxTLSEntry + 1) * sizeof(uint64_t) <= x86lp->gdtSize()); assert((maxTLSEntry + 1) * sizeof(uint64_t) <= x86lp->gdtSize());
TypedBufferArg<UserDesc32> userDesc(process->getSyscallArg(tc, 0)); int argIndex = 0;
TypedBufferArg<UserDesc32> userDesc(process->getSyscallArg(tc, argIndex));
TypedBufferArg<uint64_t> TypedBufferArg<uint64_t>
gdt(x86lp->gdtStart() + minTLSEntry * sizeof(uint64_t), gdt(x86lp->gdtStart() + minTLSEntry * sizeof(uint64_t),
numTLSEntries * sizeof(uint64_t)); numTLSEntries * sizeof(uint64_t));

19
src/arch/x86/process.cc
View file

@ -698,10 +698,10 @@ X86LiveProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn return_value)
} }
X86ISA::IntReg X86ISA::IntReg
X86_64LiveProcess::getSyscallArg(ThreadContext *tc, int i) X86_64LiveProcess::getSyscallArg(ThreadContext *tc, int &i)
{ {
assert(i < NumArgumentRegs); assert(i < NumArgumentRegs);
return tc->readIntReg(ArgumentReg[i]); return tc->readIntReg(ArgumentReg[i++]);
} }
void void
@ -712,10 +712,21 @@ X86_64LiveProcess::setSyscallArg(ThreadContext *tc, int i, X86ISA::IntReg val)
} }
X86ISA::IntReg X86ISA::IntReg
I386LiveProcess::getSyscallArg(ThreadContext *tc, int i) I386LiveProcess::getSyscallArg(ThreadContext *tc, int &i)
{ {
assert(i < NumArgumentRegs32); assert(i < NumArgumentRegs32);
return tc->readIntReg(ArgumentReg32[i]); return tc->readIntReg(ArgumentReg32[i++]);
}
X86ISA::IntReg
I386LiveProcess::getSyscallArg(ThreadContext *tc, int &i, int width)
{
assert(width == 32 || width == 64);
assert(i < NumArgumentRegs);
uint64_t retVal = tc->readIntReg(ArgumentReg32[i++]) & mask(32);
if (width == 64)
retVal |= ((uint64_t)tc->readIntReg(ArgumentReg[i++]) << 32);
return retVal;
} }
void void

5
src/arch/x86/process.hh
View file

@ -105,7 +105,7 @@ namespace X86ISA
void argsInit(int intSize, int pageSize); void argsInit(int intSize, int pageSize);
void startup(); void startup();
X86ISA::IntReg getSyscallArg(ThreadContext *tc, int i); X86ISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
void setSyscallArg(ThreadContext *tc, int i, X86ISA::IntReg val); void setSyscallArg(ThreadContext *tc, int i, X86ISA::IntReg val);
}; };
@ -130,7 +130,8 @@ namespace X86ISA
void startup(); void startup();
void syscall(int64_t callnum, ThreadContext *tc); void syscall(int64_t callnum, ThreadContext *tc);
X86ISA::IntReg getSyscallArg(ThreadContext *tc, int i); X86ISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
X86ISA::IntReg getSyscallArg(ThreadContext *tc, int &i, int width);
void setSyscallArg(ThreadContext *tc, int i, X86ISA::IntReg val); void setSyscallArg(ThreadContext *tc, int i, X86ISA::IntReg val);
}; };
} }

77
src/kern/tru64/tru64.hh
View file

@ -440,10 +440,11 @@ class Tru64 : public OperatingSystem
#ifdef __CYGWIN__ #ifdef __CYGWIN__
panic("getdirent not implemented on cygwin!"); panic("getdirent not implemented on cygwin!");
#else #else
int fd = process->sim_fd(process->getSyscallArg(tc, 0)); int index = 0;
Addr tgt_buf = process->getSyscallArg(tc, 1); int fd = process->sim_fd(process->getSyscallArg(tc, index));
int tgt_nbytes = process->getSyscallArg(tc, 2); Addr tgt_buf = process->getSyscallArg(tc, index);
Addr tgt_basep = process->getSyscallArg(tc, 3); int tgt_nbytes = process->getSyscallArg(tc, index);
Addr tgt_basep = process->getSyscallArg(tc, index);
char * const host_buf = new char[tgt_nbytes]; char * const host_buf = new char[tgt_nbytes];
@ -498,7 +499,8 @@ class Tru64 : public OperatingSystem
{ {
using namespace TheISA; using namespace TheISA;
TypedBufferArg<Tru64::sigcontext> sc(process->getSyscallArg(tc, 0)); int index = 0;
TypedBufferArg<Tru64::sigcontext> sc(process->getSyscallArg(tc, index));
sc.copyIn(tc->getMemPort()); sc.copyIn(tc->getMemPort());
@ -530,7 +532,8 @@ class Tru64 : public OperatingSystem
{ {
using namespace TheISA; using namespace TheISA;
TypedBufferArg<Tru64::vm_stack> argp(process->getSyscallArg(tc, 0)); int index = 0;
TypedBufferArg<Tru64::vm_stack> argp(process->getSyscallArg(tc, index));
argp.copyIn(tc->getMemPort()); argp.copyIn(tc->getMemPort());
@ -578,9 +581,10 @@ class Tru64 : public OperatingSystem
using namespace std; using namespace std;
using namespace TheISA; using namespace TheISA;
int index = 0;
TypedBufferArg<Tru64::nxm_task_attr> TypedBufferArg<Tru64::nxm_task_attr>
attrp(process->getSyscallArg(tc, 0)); attrp(process->getSyscallArg(tc, index));
TypedBufferArg<Addr> configptr_ptr(process->getSyscallArg(tc, 1)); TypedBufferArg<Addr> configptr_ptr(process->getSyscallArg(tc, index));
attrp.copyIn(tc->getMemPort()); attrp.copyIn(tc->getMemPort());
@ -712,10 +716,11 @@ class Tru64 : public OperatingSystem
using namespace std; using namespace std;
using namespace TheISA; using namespace TheISA;
int index = 0;
TypedBufferArg<Tru64::nxm_thread_attr> TypedBufferArg<Tru64::nxm_thread_attr>
attrp(process->getSyscallArg(tc, 0)); attrp(process->getSyscallArg(tc, index));
TypedBufferArg<uint64_t> kidp(process->getSyscallArg(tc, 1)); TypedBufferArg<uint64_t> kidp(process->getSyscallArg(tc, index));
int thread_index = process->getSyscallArg(tc, 2); int thread_index = process->getSyscallArg(tc, index);
// get attribute args // get attribute args
attrp.copyIn(tc->getMemPort()); attrp.copyIn(tc->getMemPort());
@ -834,11 +839,12 @@ class Tru64 : public OperatingSystem
{ {
using namespace std; using namespace std;
uint64_t tid = process->getSyscallArg(tc, 0); int index = 0;
uint64_t secs = process->getSyscallArg(tc, 1); uint64_t tid = process->getSyscallArg(tc, index);
uint64_t flags = process->getSyscallArg(tc, 2); uint64_t secs = process->getSyscallArg(tc, index);
uint64_t action = process->getSyscallArg(tc, 3); uint64_t flags = process->getSyscallArg(tc, index);
uint64_t usecs = process->getSyscallArg(tc, 4); uint64_t action = process->getSyscallArg(tc, index);
uint64_t usecs = process->getSyscallArg(tc, index);
cout << tc->getCpuPtr()->name() << ": nxm_thread_block " << tid << " " cout << tc->getCpuPtr()->name() << ": nxm_thread_block " << tid << " "
<< secs << " " << flags << " " << action << " " << usecs << endl; << secs << " " << flags << " " << action << " " << usecs << endl;
@ -853,11 +859,12 @@ class Tru64 : public OperatingSystem
{ {
using namespace std; using namespace std;
Addr uaddr = process->getSyscallArg(tc, 0); int index = 0;
uint64_t val = process->getSyscallArg(tc, 1); Addr uaddr = process->getSyscallArg(tc, index);
uint64_t secs = process->getSyscallArg(tc, 2); uint64_t val = process->getSyscallArg(tc, index);
uint64_t usecs = process->getSyscallArg(tc, 3); uint64_t secs = process->getSyscallArg(tc, index);
uint64_t flags = process->getSyscallArg(tc, 4); uint64_t usecs = process->getSyscallArg(tc, index);
uint64_t flags = process->getSyscallArg(tc, index);
BaseCPU *cpu = tc->getCpuPtr(); BaseCPU *cpu = tc->getCpuPtr();
@ -876,7 +883,8 @@ class Tru64 : public OperatingSystem
{ {
using namespace std; using namespace std;
Addr uaddr = process->getSyscallArg(tc, 0); int index = 0;
Addr uaddr = process->getSyscallArg(tc, index);
cout << tc->getCpuPtr()->name() << ": nxm_unblock " cout << tc->getCpuPtr()->name() << ": nxm_unblock "
<< hex << uaddr << dec << endl; << hex << uaddr << dec << endl;
@ -977,7 +985,8 @@ class Tru64 : public OperatingSystem
m5_mutex_lockFunc(SyscallDesc *desc, int callnum, LiveProcess *process, m5_mutex_lockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
Addr uaddr = process->getSyscallArg(tc, 0); int index = 0;
Addr uaddr = process->getSyscallArg(tc, index);
m5_lock_mutex(uaddr, process, tc); m5_lock_mutex(uaddr, process, tc);
@ -994,7 +1003,8 @@ class Tru64 : public OperatingSystem
{ {
using namespace TheISA; using namespace TheISA;
Addr uaddr = process->getSyscallArg(tc, 0); int index = 0;
Addr uaddr = process->getSyscallArg(tc, index);
TypedBufferArg<uint64_t> lockp(uaddr); TypedBufferArg<uint64_t> lockp(uaddr);
lockp.copyIn(tc->getMemPort()); lockp.copyIn(tc->getMemPort());
@ -1014,7 +1024,8 @@ class Tru64 : public OperatingSystem
m5_mutex_unlockFunc(SyscallDesc *desc, int callnum, LiveProcess *process, m5_mutex_unlockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
Addr uaddr = process->getSyscallArg(tc, 0); int index = 0;
Addr uaddr = process->getSyscallArg(tc, index);
m5_unlock_mutex(uaddr, process, tc); m5_unlock_mutex(uaddr, process, tc);
@ -1026,7 +1037,8 @@ class Tru64 : public OperatingSystem
m5_cond_signalFunc(SyscallDesc *desc, int callnum, LiveProcess *process, m5_cond_signalFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
Addr cond_addr = process->getSyscallArg(tc, 0); int index = 0;
Addr cond_addr = process->getSyscallArg(tc, index);
// Wake up one process waiting on the condition variable. // Wake up one process waiting on the condition variable.
activate_waiting_context(cond_addr, process); activate_waiting_context(cond_addr, process);
@ -1039,7 +1051,8 @@ class Tru64 : public OperatingSystem
m5_cond_broadcastFunc(SyscallDesc *desc, int callnum, LiveProcess *process, m5_cond_broadcastFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
Addr cond_addr = process->getSyscallArg(tc, 0); int index = 0;
Addr cond_addr = process->getSyscallArg(tc, index);
activate_waiting_context(cond_addr, process, true); activate_waiting_context(cond_addr, process, true);
@ -1053,8 +1066,9 @@ class Tru64 : public OperatingSystem
{ {
using namespace TheISA; using namespace TheISA;
Addr cond_addr = process->getSyscallArg(tc, 0); int index = 0;
Addr lock_addr = process->getSyscallArg(tc, 1); Addr cond_addr = process->getSyscallArg(tc, index);
Addr lock_addr = process->getSyscallArg(tc, index);
TypedBufferArg<uint64_t> condp(cond_addr); TypedBufferArg<uint64_t> condp(cond_addr);
TypedBufferArg<uint64_t> lockp(lock_addr); TypedBufferArg<uint64_t> lockp(lock_addr);
@ -1086,10 +1100,11 @@ class Tru64 : public OperatingSystem
indirectSyscallFunc(SyscallDesc *desc, int callnum, LiveProcess *process, indirectSyscallFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
int new_callnum = process->getSyscallArg(tc, 0); int index = 0;
int new_callnum = process->getSyscallArg(tc, index);
for (int i = 0; i < 5; ++i) for (int i = 0; i < 5; ++i)
process->setSyscallArg(tc, i, process->getSyscallArg(tc, i+1)); process->setSyscallArg(tc, i, process->getSyscallArg(tc, index));
SyscallDesc *new_desc = process->getDesc(new_callnum); SyscallDesc *new_desc = process->getDesc(new_callnum);

6
src/sim/process.cc
View file

@ -647,6 +647,12 @@ LiveProcess::syscall(int64_t callnum, ThreadContext *tc)
desc->doSyscall(callnum, this, tc); desc->doSyscall(callnum, this, tc);
} }
IntReg
LiveProcess::getSyscallArg(ThreadContext *tc, int &i, int width)
{
return getSyscallArg(tc, i);
}
LiveProcess * LiveProcess *
LiveProcess::create(LiveProcessParams * params) LiveProcess::create(LiveProcessParams * params)
{ {

4
src/sim/process.hh
View file

@ -325,7 +325,9 @@ class LiveProcess : public Process
std::string getcwd() const { return cwd; } std::string getcwd() const { return cwd; }
virtual void syscall(int64_t callnum, ThreadContext *tc); virtual void syscall(int64_t callnum, ThreadContext *tc);
virtual TheISA::IntReg getSyscallArg(ThreadContext *tc, int i) = 0;
virtual TheISA::IntReg getSyscallArg(ThreadContext *tc, int &i) = 0;
virtual TheISA::IntReg getSyscallArg(ThreadContext *tc, int &i, int width);
virtual void setSyscallArg(ThreadContext *tc, virtual void setSyscallArg(ThreadContext *tc,
int i, TheISA::IntReg val) = 0; int i, TheISA::IntReg val) = 0;
virtual void setSyscallReturn(ThreadContext *tc, virtual void setSyscallReturn(ThreadContext *tc,

153
src/sim/syscall_emul.cc
View file

@ -52,11 +52,14 @@ using namespace TheISA;
void void
SyscallDesc::doSyscall(int callnum, LiveProcess *process, ThreadContext *tc) SyscallDesc::doSyscall(int callnum, LiveProcess *process, ThreadContext *tc)
{ {
int index = 0;
DPRINTFR(SyscallVerbose, DPRINTFR(SyscallVerbose,
"%d: %s: syscall %s called w/arguments %d,%d,%d,%d\n", "%d: %s: syscall %s called w/arguments %d,%d,%d,%d\n",
curTick, tc->getCpuPtr()->name(), name, curTick, tc->getCpuPtr()->name(), name,
process->getSyscallArg(tc, 0), process->getSyscallArg(tc, 1), process->getSyscallArg(tc, index),
process->getSyscallArg(tc, 2), process->getSyscallArg(tc, 3)); process->getSyscallArg(tc, index),
process->getSyscallArg(tc, index),
process->getSyscallArg(tc, index));
SyscallReturn retval = (*funcPtr)(this, callnum, process, tc); SyscallReturn retval = (*funcPtr)(this, callnum, process, tc);
@ -82,8 +85,9 @@ SyscallReturn
ignoreFunc(SyscallDesc *desc, int callnum, LiveProcess *process, ignoreFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
int index = 0;
warn("ignoring syscall %s(%d, %d, ...)", desc->name, warn("ignoring syscall %s(%d, %d, ...)", desc->name,
process->getSyscallArg(tc, 0), process->getSyscallArg(tc, 1)); process->getSyscallArg(tc, index), process->getSyscallArg(tc, index));
return 0; return 0;
} }
@ -95,8 +99,9 @@ exitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
{ {
if (process->system->numRunningContexts() == 1) { if (process->system->numRunningContexts() == 1) {
// Last running context... exit simulator // Last running context... exit simulator
int index = 0;
exitSimLoop("target called exit()", exitSimLoop("target called exit()",
process->getSyscallArg(tc, 0) & 0xff); process->getSyscallArg(tc, index) & 0xff);
} else { } else {
// other running threads... just halt this one // other running threads... just halt this one
tc->halt(); tc->halt();
@ -112,8 +117,9 @@ exitGroupFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
{ {
// really should just halt all thread contexts belonging to this // really should just halt all thread contexts belonging to this
// process in case there's another process running... // process in case there's another process running...
int index = 0;
exitSimLoop("target called exit()", exitSimLoop("target called exit()",
process->getSyscallArg(tc, 0) & 0xff); process->getSyscallArg(tc, index) & 0xff);
return 1; return 1;
} }
@ -130,7 +136,8 @@ SyscallReturn
brkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) brkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
// change brk addr to first arg // change brk addr to first arg
Addr new_brk = p->getSyscallArg(tc, 0); int index = 0;
Addr new_brk = p->getSyscallArg(tc, index);
// in Linux at least, brk(0) returns the current break value // in Linux at least, brk(0) returns the current break value
// (note that the syscall and the glibc function have different behavior) // (note that the syscall and the glibc function have different behavior)
@ -174,7 +181,8 @@ brkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
SyscallReturn SyscallReturn
closeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) closeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
int target_fd = p->getSyscallArg(tc, 0); int index = 0;
int target_fd = p->getSyscallArg(tc, index);
int status = close(p->sim_fd(target_fd)); int status = close(p->sim_fd(target_fd));
if (status >= 0) if (status >= 0)
p->free_fd(target_fd); p->free_fd(target_fd);
@ -185,9 +193,11 @@ closeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
SyscallReturn SyscallReturn
readFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) readFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
int fd = p->sim_fd(p->getSyscallArg(tc, 0)); int index = 0;
int nbytes = p->getSyscallArg(tc, 2); int fd = p->sim_fd(p->getSyscallArg(tc, index));
BufferArg bufArg(p->getSyscallArg(tc, 1), nbytes); Addr bufPtr = p->getSyscallArg(tc, index);
int nbytes = p->getSyscallArg(tc, index);
BufferArg bufArg(bufPtr, nbytes);
int bytes_read = read(fd, bufArg.bufferPtr(), nbytes); int bytes_read = read(fd, bufArg.bufferPtr(), nbytes);
@ -200,9 +210,11 @@ readFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
SyscallReturn SyscallReturn
writeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) writeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
int fd = p->sim_fd(p->getSyscallArg(tc, 0)); int index = 0;
int nbytes = p->getSyscallArg(tc, 2); int fd = p->sim_fd(p->getSyscallArg(tc, index));
BufferArg bufArg(p->getSyscallArg(tc, 1), nbytes); Addr bufPtr = p->getSyscallArg(tc, index);
int nbytes = p->getSyscallArg(tc, index);
BufferArg bufArg(bufPtr, nbytes);
bufArg.copyIn(tc->getMemPort()); bufArg.copyIn(tc->getMemPort());
@ -217,9 +229,10 @@ writeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
SyscallReturn SyscallReturn
lseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) lseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
int fd = p->sim_fd(p->getSyscallArg(tc, 0)); int index = 0;
uint64_t offs = p->getSyscallArg(tc, 1); int fd = p->sim_fd(p->getSyscallArg(tc, index));
int whence = p->getSyscallArg(tc, 2); uint64_t offs = p->getSyscallArg(tc, index);
int whence = p->getSyscallArg(tc, index);
off_t result = lseek(fd, offs, whence); off_t result = lseek(fd, offs, whence);
@ -230,11 +243,12 @@ lseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
SyscallReturn SyscallReturn
_llseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) _llseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
int fd = p->sim_fd(p->getSyscallArg(tc, 0)); int index = 0;
uint64_t offset_high = p->getSyscallArg(tc, 1); int fd = p->sim_fd(p->getSyscallArg(tc, index));
uint32_t offset_low = p->getSyscallArg(tc, 2); uint64_t offset_high = p->getSyscallArg(tc, index);
Addr result_ptr = p->getSyscallArg(tc, 3); uint32_t offset_low = p->getSyscallArg(tc, index);
int whence = p->getSyscallArg(tc, 4); Addr result_ptr = p->getSyscallArg(tc, index);
int whence = p->getSyscallArg(tc, index);
uint64_t offset = (offset_high << 32) | offset_low; uint64_t offset = (offset_high << 32) | offset_low;
@ -273,8 +287,10 @@ const char *hostname = "m5.eecs.umich.edu";
SyscallReturn SyscallReturn
gethostnameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) gethostnameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
int name_len = p->getSyscallArg(tc, 1); int index = 0;
BufferArg name(p->getSyscallArg(tc, 0), name_len); Addr bufPtr = p->getSyscallArg(tc, index);
int name_len = p->getSyscallArg(tc, index);
BufferArg name(bufPtr, name_len);
strncpy((char *)name.bufferPtr(), hostname, name_len); strncpy((char *)name.bufferPtr(), hostname, name_len);
@ -287,8 +303,10 @@ SyscallReturn
getcwdFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) getcwdFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
int result = 0; int result = 0;
unsigned long size = p->getSyscallArg(tc, 1); int index;
BufferArg buf(p->getSyscallArg(tc, 0), size); Addr bufPtr = p->getSyscallArg(tc, index);
unsigned long size = p->getSyscallArg(tc, index);
BufferArg buf(bufPtr, size);
// Is current working directory defined? // Is current working directory defined?
string cwd = p->getcwd(); string cwd = p->getcwd();
@ -320,14 +338,17 @@ readlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
string path; string path;
if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
return (TheISA::IntReg)-EFAULT; return (TheISA::IntReg)-EFAULT;
// Adjust path for current working directory // Adjust path for current working directory
path = p->fullPath(path); path = p->fullPath(path);
size_t bufsiz = p->getSyscallArg(tc, 2); Addr bufPtr = p->getSyscallArg(tc, index);
BufferArg buf(p->getSyscallArg(tc, 1), bufsiz); size_t bufsiz = p->getSyscallArg(tc, index);
BufferArg buf(bufPtr, bufsiz);
int result = readlink(path.c_str(), (char *)buf.bufferPtr(), bufsiz); int result = readlink(path.c_str(), (char *)buf.bufferPtr(), bufsiz);
@ -341,7 +362,8 @@ unlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
string path; string path;
if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
return (TheISA::IntReg)-EFAULT; return (TheISA::IntReg)-EFAULT;
// Adjust path for current working directory // Adjust path for current working directory
@ -357,13 +379,14 @@ mkdirFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
string path; string path;
if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
return (TheISA::IntReg)-EFAULT; return (TheISA::IntReg)-EFAULT;
// Adjust path for current working directory // Adjust path for current working directory
path = p->fullPath(path); path = p->fullPath(path);
mode_t mode = p->getSyscallArg(tc, 1); mode_t mode = p->getSyscallArg(tc, index);
int result = mkdir(path.c_str(), mode); int result = mkdir(path.c_str(), mode);
return (result == -1) ? -errno : result; return (result == -1) ? -errno : result;
@ -374,12 +397,13 @@ renameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
string old_name; string old_name;
if (!tc->getMemPort()->tryReadString(old_name, p->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(old_name, p->getSyscallArg(tc, index)))
return -EFAULT; return -EFAULT;
string new_name; string new_name;
if (!tc->getMemPort()->tryReadString(new_name, p->getSyscallArg(tc, 1))) if (!tc->getMemPort()->tryReadString(new_name, p->getSyscallArg(tc, index)))
return -EFAULT; return -EFAULT;
// Adjust path for current working directory // Adjust path for current working directory
@ -395,10 +419,11 @@ truncateFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
string path; string path;
if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
return -EFAULT; return -EFAULT;
off_t length = p->getSyscallArg(tc, 1); off_t length = p->getSyscallArg(tc, index);
// Adjust path for current working directory // Adjust path for current working directory
path = p->fullPath(path); path = p->fullPath(path);
@ -411,12 +436,13 @@ SyscallReturn
ftruncateFunc(SyscallDesc *desc, int num, ftruncateFunc(SyscallDesc *desc, int num,
LiveProcess *process, ThreadContext *tc) LiveProcess *process, ThreadContext *tc)
{ {
int fd = process->sim_fd(process->getSyscallArg(tc, 0)); int index = 0;
int fd = process->sim_fd(process->getSyscallArg(tc, index));
if (fd < 0) if (fd < 0)
return -EBADF; return -EBADF;
off_t length = process->getSyscallArg(tc, 1); off_t length = process->getSyscallArg(tc, index);
int result = ftruncate(fd, length); int result = ftruncate(fd, length);
return (result == -1) ? -errno : result; return (result == -1) ? -errno : result;
@ -426,13 +452,13 @@ SyscallReturn
ftruncate64Func(SyscallDesc *desc, int num, ftruncate64Func(SyscallDesc *desc, int num,
LiveProcess *process, ThreadContext *tc) LiveProcess *process, ThreadContext *tc)
{ {
int fd = process->sim_fd(process->getSyscallArg(tc, 0)); int index = 0;
int fd = process->sim_fd(process->getSyscallArg(tc, index));
if (fd < 0) if (fd < 0)
return -EBADF; return -EBADF;
// I'm not sure why, but the length argument is in arg reg 3 loff_t length = process->getSyscallArg(tc, index, 64);
loff_t length = process->getSyscallArg(tc, 3);
int result = ftruncate64(fd, length); int result = ftruncate64(fd, length);
return (result == -1) ? -errno : result; return (result == -1) ? -errno : result;
@ -454,13 +480,14 @@ chownFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
string path; string path;
if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
return -EFAULT; return -EFAULT;
/* XXX endianess */ /* XXX endianess */
uint32_t owner = p->getSyscallArg(tc, 1); uint32_t owner = p->getSyscallArg(tc, index);
uid_t hostOwner = owner; uid_t hostOwner = owner;
uint32_t group = p->getSyscallArg(tc, 2); uint32_t group = p->getSyscallArg(tc, index);
gid_t hostGroup = group; gid_t hostGroup = group;
// Adjust path for current working directory // Adjust path for current working directory
@ -473,15 +500,16 @@ chownFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
SyscallReturn SyscallReturn
fchownFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc) fchownFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
{ {
int fd = process->sim_fd(process->getSyscallArg(tc, 0)); int index = 0;
int fd = process->sim_fd(process->getSyscallArg(tc, index));
if (fd < 0) if (fd < 0)
return -EBADF; return -EBADF;
/* XXX endianess */ /* XXX endianess */
uint32_t owner = process->getSyscallArg(tc, 1); uint32_t owner = process->getSyscallArg(tc, index);
uid_t hostOwner = owner; uid_t hostOwner = owner;
uint32_t group = process->getSyscallArg(tc, 2); uint32_t group = process->getSyscallArg(tc, index);
gid_t hostGroup = group; gid_t hostGroup = group;
int result = fchown(fd, hostOwner, hostGroup); int result = fchown(fd, hostOwner, hostGroup);
@ -492,11 +520,12 @@ fchownFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
SyscallReturn SyscallReturn
dupFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc) dupFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
{ {
int fd = process->sim_fd(process->getSyscallArg(tc, 0)); int index = 0;
int fd = process->sim_fd(process->getSyscallArg(tc, index));
if (fd < 0) if (fd < 0)
return -EBADF; return -EBADF;
Process::FdMap *fdo = process->sim_fd_obj(process->getSyscallArg(tc, 0)); Process::FdMap *fdo = process->sim_fd_obj(fd);
int result = dup(fd); int result = dup(fd);
return (result == -1) ? -errno : return (result == -1) ? -errno :
@ -508,12 +537,13 @@ SyscallReturn
fcntlFunc(SyscallDesc *desc, int num, LiveProcess *process, fcntlFunc(SyscallDesc *desc, int num, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
int fd = process->getSyscallArg(tc, 0); int index = 0;
int fd = process->getSyscallArg(tc, index);
if (fd < 0 || process->sim_fd(fd) < 0) if (fd < 0 || process->sim_fd(fd) < 0)
return -EBADF; return -EBADF;
int cmd = process->getSyscallArg(tc, 1); int cmd = process->getSyscallArg(tc, index);
switch (cmd) { switch (cmd) {
case 0: // F_DUPFD case 0: // F_DUPFD
// if we really wanted to support this, we'd need to do it // if we really wanted to support this, we'd need to do it
@ -550,12 +580,13 @@ SyscallReturn
fcntl64Func(SyscallDesc *desc, int num, LiveProcess *process, fcntl64Func(SyscallDesc *desc, int num, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
int fd = process->getSyscallArg(tc, 0); int index = 0;
int fd = process->getSyscallArg(tc, index);
if (fd < 0 || process->sim_fd(fd) < 0) if (fd < 0 || process->sim_fd(fd) < 0)
return -EBADF; return -EBADF;
int cmd = process->getSyscallArg(tc, 1); int cmd = process->getSyscallArg(tc, index);
switch (cmd) { switch (cmd) {
case 33: //F_GETLK64 case 33: //F_GETLK64
warn("fcntl64(%d, F_GETLK64) not supported, error returned\n", fd); warn("fcntl64(%d, F_GETLK64) not supported, error returned\n", fd);
@ -639,7 +670,8 @@ setuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
// can't fathom why a benchmark would call this. // can't fathom why a benchmark would call this.
warn("Ignoring call to setuid(%d)\n", process->getSyscallArg(tc, 0)); int index = 0;
warn("Ignoring call to setuid(%d)\n", process->getSyscallArg(tc, index));
return 0; return 0;
} }
@ -695,17 +727,20 @@ SyscallReturn
cloneFunc(SyscallDesc *desc, int callnum, LiveProcess *process, cloneFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
int index = 0;
IntReg flags = process->getSyscallArg(tc, index);
IntReg newStack = process->getSyscallArg(tc, index);
DPRINTF(SyscallVerbose, "In sys_clone:\n"); DPRINTF(SyscallVerbose, "In sys_clone:\n");
DPRINTF(SyscallVerbose, " Flags=%llx\n", process->getSyscallArg(tc, 0)); DPRINTF(SyscallVerbose, " Flags=%llx\n", flags);
DPRINTF(SyscallVerbose, " Child stack=%llx\n", DPRINTF(SyscallVerbose, " Child stack=%llx\n", newStack);
process->getSyscallArg(tc, 1));
if (process->getSyscallArg(tc, 0) != 0x10f00) { if (flags != 0x10f00) {
warn("This sys_clone implementation assumes flags " warn("This sys_clone implementation assumes flags "
"CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD " "CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD "
"(0x10f00), and may not work correctly with given flags " "(0x10f00), and may not work correctly with given flags "
"0x%llx\n", process->getSyscallArg(tc, 0)); "0x%llx\n", flags);
} }
ThreadContext* ctc; // child thread context ThreadContext* ctc; // child thread context
@ -738,7 +773,7 @@ cloneFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
#endif #endif
// Set up stack register // Set up stack register
ctc->setIntReg(TheISA::StackPointerReg, process->getSyscallArg(tc, 1)); ctc->setIntReg(TheISA::StackPointerReg, newStack);
// Set up syscall return values in parent and child // Set up syscall return values in parent and child
ctc->setIntReg(ReturnValueReg, 0); // return value, child ctc->setIntReg(ReturnValueReg, 0); // return value, child

152
src/sim/syscall_emul.hh
View file

@ -481,8 +481,9 @@ SyscallReturn
ioctlFunc(SyscallDesc *desc, int callnum, LiveProcess *process, ioctlFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
int fd = process->getSyscallArg(tc, 0); int index = 0;
unsigned req = process->getSyscallArg(tc, 1); int fd = process->getSyscallArg(tc, index);
unsigned req = process->getSyscallArg(tc, index);
DPRINTF(SyscallVerbose, "ioctl(%d, 0x%x, ...)\n", fd, req); DPRINTF(SyscallVerbose, "ioctl(%d, 0x%x, ...)\n", fd, req);
@ -517,7 +518,9 @@ openFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
{ {
std::string path; std::string path;
if (!tc->getMemPort()->tryReadString(path, process->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(path,
process->getSyscallArg(tc, index)))
return -EFAULT; return -EFAULT;
if (path == "/dev/sysdev0") { if (path == "/dev/sysdev0") {
@ -527,8 +530,8 @@ openFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
return -ENOENT; return -ENOENT;
} }
int tgtFlags = process->getSyscallArg(tc, 1); int tgtFlags = process->getSyscallArg(tc, index);
int mode = process->getSyscallArg(tc, 2); int mode = process->getSyscallArg(tc, index);
int hostFlags = 0; int hostFlags = 0;
// translate open flags // translate open flags
@ -573,7 +576,9 @@ sysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
TypedBufferArg<typename OS::tgt_sysinfo> sysinfo(process->getSyscallArg(tc, 0)); int index = 0;
TypedBufferArg<typename OS::tgt_sysinfo>
sysinfo(process->getSyscallArg(tc, index));
sysinfo->uptime=seconds_since_epoch; sysinfo->uptime=seconds_since_epoch;
sysinfo->totalram=process->system->memSize(); sysinfo->totalram=process->system->memSize();
@ -591,10 +596,13 @@ chmodFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
{ {
std::string path; std::string path;
if (!tc->getMemPort()->tryReadString(path, process->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(path,
process->getSyscallArg(tc, index))) {
return -EFAULT; return -EFAULT;
}
uint32_t mode = process->getSyscallArg(tc, 1); uint32_t mode = process->getSyscallArg(tc, index);
mode_t hostMode = 0; mode_t hostMode = 0;
// XXX translate mode flags via OS::something??? // XXX translate mode flags via OS::something???
@ -618,13 +626,14 @@ SyscallReturn
fchmodFunc(SyscallDesc *desc, int callnum, LiveProcess *process, fchmodFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
int fd = process->getSyscallArg(tc, 0); int index = 0;
int fd = process->getSyscallArg(tc, index);
if (fd < 0 || process->sim_fd(fd) < 0) { if (fd < 0 || process->sim_fd(fd) < 0) {
// doesn't map to any simulator fd: not a valid target fd // doesn't map to any simulator fd: not a valid target fd
return -EBADF; return -EBADF;
} }
uint32_t mode = process->getSyscallArg(tc, 1); uint32_t mode = process->getSyscallArg(tc, index);
mode_t hostMode = 0; mode_t hostMode = 0;
// XXX translate mode flags via OS::someting??? // XXX translate mode flags via OS::someting???
@ -643,10 +652,11 @@ template <class OS>
SyscallReturn SyscallReturn
mremapFunc(SyscallDesc *desc, int callnum, LiveProcess *process, ThreadContext *tc) mremapFunc(SyscallDesc *desc, int callnum, LiveProcess *process, ThreadContext *tc)
{ {
Addr start = process->getSyscallArg(tc, 0); int index = 0;
uint64_t old_length = process->getSyscallArg(tc, 1); Addr start = process->getSyscallArg(tc, index);
uint64_t new_length = process->getSyscallArg(tc, 2); uint64_t old_length = process->getSyscallArg(tc, index);
uint64_t flags = process->getSyscallArg(tc, 3); uint64_t new_length = process->getSyscallArg(tc, index);
uint64_t flags = process->getSyscallArg(tc, index);
if ((start % TheISA::VMPageSize != 0) || if ((start % TheISA::VMPageSize != 0) ||
(new_length % TheISA::VMPageSize != 0)) { (new_length % TheISA::VMPageSize != 0)) {
@ -692,8 +702,12 @@ statFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
{ {
std::string path; std::string path;
if (!tc->getMemPort()->tryReadString(path, process->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(path,
process->getSyscallArg(tc, index))) {
return -EFAULT; return -EFAULT;
}
Addr bufPtr = process->getSyscallArg(tc, index);
// Adjust path for current working directory // Adjust path for current working directory
path = process->fullPath(path); path = process->fullPath(path);
@ -704,8 +718,7 @@ statFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
if (result < 0) if (result < 0)
return -errno; return -errno;
copyOutStatBuf<OS>(tc->getMemPort(), process->getSyscallArg(tc, 1), copyOutStatBuf<OS>(tc->getMemPort(), bufPtr, &hostBuf);
&hostBuf);
return 0; return 0;
} }
@ -719,8 +732,11 @@ stat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
{ {
std::string path; std::string path;
if (!tc->getMemPort()->tryReadString(path, process->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(path,
process->getSyscallArg(tc, index)))
return -EFAULT; return -EFAULT;
Addr bufPtr = process->getSyscallArg(tc, index);
// Adjust path for current working directory // Adjust path for current working directory
path = process->fullPath(path); path = process->fullPath(path);
@ -736,8 +752,7 @@ stat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
if (result < 0) if (result < 0)
return -errno; return -errno;
copyOutStat64Buf<OS>(tc->getMemPort(), process->getSyscallArg(tc, 1), copyOutStat64Buf<OS>(tc->getMemPort(), bufPtr, &hostBuf);
&hostBuf);
return 0; return 0;
} }
@ -749,7 +764,9 @@ SyscallReturn
fstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process, fstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
int fd = process->getSyscallArg(tc, 0); int index = 0;
int fd = process->getSyscallArg(tc, index);
Addr bufPtr = process->getSyscallArg(tc, index);
if (fd < 0 || process->sim_fd(fd) < 0) { if (fd < 0 || process->sim_fd(fd) < 0) {
// doesn't map to any simulator fd: not a valid target fd // doesn't map to any simulator fd: not a valid target fd
return -EBADF; return -EBADF;
@ -766,8 +783,7 @@ fstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
if (result < 0) if (result < 0)
return -errno; return -errno;
copyOutStat64Buf<OS>(tc->getMemPort(), process->getSyscallArg(tc, 1), copyOutStat64Buf<OS>(tc->getMemPort(), bufPtr, &hostBuf, (fd == 1));
&hostBuf, (fd == 1));
return 0; return 0;
} }
@ -781,8 +797,12 @@ lstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
{ {
std::string path; std::string path;
if (!tc->getMemPort()->tryReadString(path, process->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(path,
process->getSyscallArg(tc, index))) {
return -EFAULT; return -EFAULT;
}
Addr bufPtr = process->getSyscallArg(tc, index);
// Adjust path for current working directory // Adjust path for current working directory
path = process->fullPath(path); path = process->fullPath(path);
@ -793,8 +813,7 @@ lstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
if (result < 0) if (result < 0)
return -errno; return -errno;
copyOutStatBuf<OS>(tc->getMemPort(), process->getSyscallArg(tc, 1), copyOutStatBuf<OS>(tc->getMemPort(), bufPtr, &hostBuf);
&hostBuf);
return 0; return 0;
} }
@ -807,8 +826,12 @@ lstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
{ {
std::string path; std::string path;
if (!tc->getMemPort()->tryReadString(path, process->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(path,
process->getSyscallArg(tc, index))) {
return -EFAULT; return -EFAULT;
}
Addr bufPtr = process->getSyscallArg(tc, index);
// Adjust path for current working directory // Adjust path for current working directory
path = process->fullPath(path); path = process->fullPath(path);
@ -824,8 +847,7 @@ lstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
if (result < 0) if (result < 0)
return -errno; return -errno;
copyOutStat64Buf<OS>(tc->getMemPort(), process->getSyscallArg(tc, 1), copyOutStat64Buf<OS>(tc->getMemPort(), bufPtr, &hostBuf);
&hostBuf);
return 0; return 0;
} }
@ -836,7 +858,9 @@ SyscallReturn
fstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process, fstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
int fd = process->sim_fd(process->getSyscallArg(tc, 0)); int index = 0;
int fd = process->sim_fd(process->getSyscallArg(tc, index));
Addr bufPtr = process->getSyscallArg(tc, index);
DPRINTF(SyscallVerbose, "fstat(%d, ...)\n", fd); DPRINTF(SyscallVerbose, "fstat(%d, ...)\n", fd);
@ -849,8 +873,7 @@ fstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
if (result < 0) if (result < 0)
return -errno; return -errno;
copyOutStatBuf<OS>(tc->getMemPort(), process->getSyscallArg(tc, 1), copyOutStatBuf<OS>(tc->getMemPort(), bufPtr, &hostBuf, (fd == 1));
&hostBuf, (fd == 1));
return 0; return 0;
} }
@ -864,8 +887,12 @@ statfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
{ {
std::string path; std::string path;
if (!tc->getMemPort()->tryReadString(path, process->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(path,
process->getSyscallArg(tc, index))) {
return -EFAULT; return -EFAULT;
}
Addr bufPtr = process->getSyscallArg(tc, index);
// Adjust path for current working directory // Adjust path for current working directory
path = process->fullPath(path); path = process->fullPath(path);
@ -876,8 +903,7 @@ statfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
if (result < 0) if (result < 0)
return -errno; return -errno;
OS::copyOutStatfsBuf(tc->getMemPort(), OS::copyOutStatfsBuf(tc->getMemPort(), bufPtr, &hostBuf);
(Addr)(process->getSyscallArg(tc, 1)), &hostBuf);
return 0; return 0;
} }
@ -889,7 +915,9 @@ SyscallReturn
fstatfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process, fstatfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
int fd = process->sim_fd(process->getSyscallArg(tc, 0)); int index = 0;
int fd = process->sim_fd(process->getSyscallArg(tc, index));
Addr bufPtr = process->getSyscallArg(tc, index);
if (fd < 0) if (fd < 0)
return -EBADF; return -EBADF;
@ -900,8 +928,7 @@ fstatfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
if (result < 0) if (result < 0)
return -errno; return -errno;
OS::copyOutStatfsBuf(tc->getMemPort(), process->getSyscallArg(tc, 1), OS::copyOutStatfsBuf(tc->getMemPort(), bufPtr, &hostBuf);
&hostBuf);
return 0; return 0;
} }
@ -913,15 +940,16 @@ SyscallReturn
writevFunc(SyscallDesc *desc, int callnum, LiveProcess *process, writevFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
int fd = process->getSyscallArg(tc, 0); int index = 0;
int fd = process->getSyscallArg(tc, index);
if (fd < 0 || process->sim_fd(fd) < 0) { if (fd < 0 || process->sim_fd(fd) < 0) {
// doesn't map to any simulator fd: not a valid target fd // doesn't map to any simulator fd: not a valid target fd
return -EBADF; return -EBADF;
} }
TranslatingPort *p = tc->getMemPort(); TranslatingPort *p = tc->getMemPort();
uint64_t tiov_base = process->getSyscallArg(tc, 1); uint64_t tiov_base = process->getSyscallArg(tc, index);
size_t count = process->getSyscallArg(tc, 2); size_t count = process->getSyscallArg(tc, index);
struct iovec hiov[count]; struct iovec hiov[count];
for (size_t i = 0; i < count; ++i) { for (size_t i = 0; i < count; ++i) {
typename OS::tgt_iovec tiov; typename OS::tgt_iovec tiov;
@ -962,12 +990,13 @@ template <class OS>
SyscallReturn SyscallReturn
mmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) mmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
{ {
Addr start = p->getSyscallArg(tc, 0); int index = 0;
uint64_t length = p->getSyscallArg(tc, 1); Addr start = p->getSyscallArg(tc, index);
// int prot = p->getSyscallArg(tc, 2); uint64_t length = p->getSyscallArg(tc, index);
int flags = p->getSyscallArg(tc, 3); index++; // int prot = p->getSyscallArg(tc, index);
// int fd = p->sim_fd(p->getSyscallArg(tc, 4)); int flags = p->getSyscallArg(tc, index);
// int offset = p->getSyscallArg(tc, 5); int fd = p->sim_fd(p->getSyscallArg(tc, index));
// int offset = p->getSyscallArg(tc, index);
if ((start % TheISA::VMPageSize) != 0 || if ((start % TheISA::VMPageSize) != 0 ||
@ -995,7 +1024,7 @@ mmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
if (!(flags & OS::TGT_MAP_ANONYMOUS)) { if (!(flags & OS::TGT_MAP_ANONYMOUS)) {
warn("allowing mmap of file @ fd %d. " warn("allowing mmap of file @ fd %d. "
"This will break if not /dev/zero.", p->getSyscallArg(tc, 4)); "This will break if not /dev/zero.", fd);
} }
return start; return start;
@ -1007,8 +1036,9 @@ SyscallReturn
getrlimitFunc(SyscallDesc *desc, int callnum, LiveProcess *process, getrlimitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
unsigned resource = process->getSyscallArg(tc, 0); int index = 0;
TypedBufferArg<typename OS::rlimit> rlp(process->getSyscallArg(tc, 1)); unsigned resource = process->getSyscallArg(tc, index);
TypedBufferArg<typename OS::rlimit> rlp(process->getSyscallArg(tc, index));
switch (resource) { switch (resource) {
case OS::TGT_RLIMIT_STACK: case OS::TGT_RLIMIT_STACK:
@ -1042,7 +1072,8 @@ SyscallReturn
gettimeofdayFunc(SyscallDesc *desc, int callnum, LiveProcess *process, gettimeofdayFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
TypedBufferArg<typename OS::timeval> tp(process->getSyscallArg(tc, 0)); int index = 0;
TypedBufferArg<typename OS::timeval> tp(process->getSyscallArg(tc, index));
getElapsedTime(tp->tv_sec, tp->tv_usec); getElapsedTime(tp->tv_sec, tp->tv_usec);
tp->tv_sec += seconds_since_epoch; tp->tv_sec += seconds_since_epoch;
@ -1063,10 +1094,14 @@ utimesFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
{ {
std::string path; std::string path;
if (!tc->getMemPort()->tryReadString(path, process->getSyscallArg(tc, 0))) int index = 0;
if (!tc->getMemPort()->tryReadString(path,
process->getSyscallArg(tc, index))) {
return -EFAULT; return -EFAULT;
}
TypedBufferArg<typename OS::timeval [2]> tp(process->getSyscallArg(tc, 1)); TypedBufferArg<typename OS::timeval [2]>
tp(process->getSyscallArg(tc, index));
tp.copyIn(tc->getMemPort()); tp.copyIn(tc->getMemPort());
struct timeval hostTimeval[2]; struct timeval hostTimeval[2];
@ -1092,8 +1127,9 @@ SyscallReturn
getrusageFunc(SyscallDesc *desc, int callnum, LiveProcess *process, getrusageFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
int who = process->getSyscallArg(tc, 0); // THREAD, SELF, or CHILDREN int index = 0;
TypedBufferArg<typename OS::rusage> rup(process->getSyscallArg(tc, 1)); int who = process->getSyscallArg(tc, index); // THREAD, SELF, or CHILDREN
TypedBufferArg<typename OS::rusage> rup(process->getSyscallArg(tc, index));
rup->ru_utime.tv_sec = 0; rup->ru_utime.tv_sec = 0;
rup->ru_utime.tv_usec = 0; rup->ru_utime.tv_usec = 0;
@ -1143,7 +1179,8 @@ SyscallReturn
timesFunc(SyscallDesc *desc, int callnum, LiveProcess *process, timesFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
ThreadContext *tc) ThreadContext *tc)
{ {
TypedBufferArg<typename OS::tms> bufp(process->getSyscallArg(tc, 0)); int index = 0;
TypedBufferArg<typename OS::tms> bufp(process->getSyscallArg(tc, index));
// Fill in the time structure (in clocks) // Fill in the time structure (in clocks)
int64_t clocks = curTick * OS::_SC_CLK_TCK / Clock::Int::s; int64_t clocks = curTick * OS::_SC_CLK_TCK / Clock::Int::s;
@ -1172,7 +1209,8 @@ timeFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
getElapsedTime(sec, usec); getElapsedTime(sec, usec);
sec += seconds_since_epoch; sec += seconds_since_epoch;
Addr taddr = (Addr)process->getSyscallArg(tc, 0); int index = 0;
Addr taddr = (Addr)process->getSyscallArg(tc, index);
if(taddr != 0) { if(taddr != 0) {
typename OS::time_t t = sec; typename OS::time_t t = sec;
t = htog(t); t = htog(t);