#include "arch/utility.hh"
#include "base/intmath.hh"
#include "base/loader/object_file.hh"
-#include "base/misc.hh"
+#include "base/logging.hh"
#include "base/trace.hh"
#include "base/types.hh"
#include "config/the_isa.hh"
//// memory space. Used by stat(), fstat(), and lstat().
template <typename target_stat, typename host_stat>
-static void
+void
convertStatBuf(target_stat &tgt, host_stat *host, bool fakeTTY = false)
{
using namespace TheISA;
// Same for stat64
template <typename target_stat, typename host_stat64>
-static void
+void
convertStat64Buf(target_stat &tgt, host_stat64 *host, bool fakeTTY = false)
{
using namespace TheISA;
// Here are a couple of convenience functions
template<class OS>
-static void
+void
copyOutStatBuf(SETranslatingPortProxy &mem, Addr addr,
hst_stat *host, bool fakeTTY = false)
{
}
template<class OS>
-static void
+void
copyOutStat64Buf(SETranslatingPortProxy &mem, Addr addr,
hst_stat64 *host, bool fakeTTY = false)
{
}
template <class OS>
-static void
+void
copyOutStatfsBuf(SETranslatingPortProxy &mem, Addr addr,
hst_statfs *host)
{
if ((start + old_length) == mmap_end &&
(!use_provided_address || provided_address == start)) {
+ // This case cannot occur when growing downward, as
+ // start is greater than or equal to mmap_end.
uint64_t diff = new_length - old_length;
process->allocateMem(mmap_end, diff);
mem_state->setMmapEnd(mmap_end + diff);
warn("can't remap here and MREMAP_MAYMOVE flag not set\n");
return -ENOMEM;
} else {
- uint64_t new_start = use_provided_address ?
- provided_address : mmap_end;
+ uint64_t new_start = provided_address;
+ if (!use_provided_address) {
+ new_start = process->mmapGrowsDown() ?
+ mmap_end - new_length : mmap_end;
+ mmap_end = process->mmapGrowsDown() ?
+ new_start : mmap_end + new_length;
+ mem_state->setMmapEnd(mmap_end);
+ }
+
process->pTable->remap(start, old_length, new_start);
warn("mremapping to new vaddr %08p-%08p, adding %d\n",
new_start, new_start + new_length,
process->allocateMem(new_start + old_length,
new_length - old_length,
use_provided_address /* clobber */);
- if (!use_provided_address)
- mem_state->setMmapEnd(mmap_end + new_length);
if (use_provided_address &&
- new_start + new_length > mem_state->getMmapEnd()) {
+ ((new_start + new_length > mem_state->getMmapEnd() &&
+ !process->mmapGrowsDown()) ||
+ (new_start < mem_state->getMmapEnd() &&
+ process->mmapGrowsDown()))) {
// something fishy going on here, at least notify the user
// @todo: increase mmap_end?
warn("mmap region limit exceeded with MREMAP_FIXED\n");
cloneFunc(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc)
{
int index = 0;
+
TheISA::IntReg flags = p->getSyscallArg(tc, index);
TheISA::IntReg newStack = p->getSyscallArg(tc, index);
Addr ptidPtr = p->getSyscallArg(tc, index);
+
+#if THE_ISA == RISCV_ISA
+ /**
+ * Linux kernel 4.15 sets CLONE_BACKWARDS flag for RISC-V.
+ * The flag defines the list of clone() arguments in the following
+ * order: flags -> newStack -> ptidPtr -> tlsPtr -> ctidPtr
+ */
+ Addr tlsPtr M5_VAR_USED = p->getSyscallArg(tc, index);
+ Addr ctidPtr = p->getSyscallArg(tc, index);
+#else
Addr ctidPtr = p->getSyscallArg(tc, index);
Addr tlsPtr M5_VAR_USED = p->getSyscallArg(tc, index);
+#endif
if (((flags & OS::TGT_CLONE_SIGHAND)&& !(flags & OS::TGT_CLONE_VM)) ||
((flags & OS::TGT_CLONE_THREAD) && !(flags & OS::TGT_CLONE_SIGHAND)) ||
ctc->setMiscReg(TheISA::MISCREG_ASI, TheISA::ASI_PRIMARY);
for (int y = 8; y < 32; y++)
ctc->setIntReg(y, tc->readIntReg(y));
-#elif THE_ISA == ARM_ISA or THE_ISA == X86_ISA
+#elif THE_ISA == ARM_ISA or THE_ISA == X86_ISA or THE_ISA == RISCV_ISA
TheISA::copyRegs(tc, ctc);
#endif
return 0;
}
+template <class OS>
+SyscallReturn
+prlimitFunc(SyscallDesc *desc, int callnum, Process *process,
+ ThreadContext *tc)
+{
+ int index = 0;
+ if (process->getSyscallArg(tc, index) != 0)
+ {
+ warn("prlimit: ignoring rlimits for nonzero pid");
+ return -EPERM;
+ }
+ int resource = process->getSyscallArg(tc, index);
+ Addr n = process->getSyscallArg(tc, index);
+ if (n != 0)
+ warn("prlimit: ignoring new rlimit");
+ Addr o = process->getSyscallArg(tc, index);
+ if (o != 0)
+ {
+ TypedBufferArg<typename OS::rlimit> rlp(o);
+ switch (resource) {
+ case OS::TGT_RLIMIT_STACK:
+ // max stack size in bytes: make up a number (8MB for now)
+ rlp->rlim_cur = rlp->rlim_max = 8 * 1024 * 1024;
+ rlp->rlim_cur = TheISA::htog(rlp->rlim_cur);
+ rlp->rlim_max = TheISA::htog(rlp->rlim_max);
+ break;
+ case OS::TGT_RLIMIT_DATA:
+ // max data segment size in bytes: make up a number
+ rlp->rlim_cur = rlp->rlim_max = 256*1024*1024;
+ rlp->rlim_cur = TheISA::htog(rlp->rlim_cur);
+ rlp->rlim_max = TheISA::htog(rlp->rlim_max);
+ default:
+ warn("prlimit: unimplemented resource %d", resource);
+ return -EINVAL;
+ break;
+ }
+ rlp.copyOut(tc->getMemProxy());
+ }
+ return 0;
+}
+
/// Target clock_gettime() function.
template <class OS>
SyscallReturn