derek/gem5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sim: Use the system and OS to get endianness.

Browse Source 
This converts the syscall implementations to either use the
OS::byteOrder constant or, if that's not available, the system's
getGuestByteOrder() accessor, to determine the byte order, instead of
relying on TheISA to provide the correct accessor.

Change-Id: Idf7b02ee8d73990224ceac9a5efaec91a5ebf79f
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/22364
Reviewed-by: Brandon Potter <Brandon.Potter@amd.com>
Maintainer: Gabe Black <gabeblack@google.com>
Tested-by: kokoro <noreply+kokoro@google.com>
This commit is contained in:
Gabe Black
2019-10-29 15:50:48 -07:00
parent 607df7e656
commit 75d496c6b2
2 changed files with 71 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/sim/syscall_emul.cc
View File

@@ -347,7 +347,7 @@ _llseekFunc(SyscallDesc *desc, int num, ThreadContext *tc)
uint64_t offset = (offset_high << 32) | offset_low;
uint64_t result = lseek(sim_fd, offset, whence);
result = TheISA::htog(result);
result = htog(result, tc->getSystemPtr()->getGuestByteOrder());
if (result == (off_t)-1)
return -errno;
@@ -1262,9 +1262,10 @@ getdentsImpl(SyscallDesc *desc, int callnum, ThreadContext *tc)
* passing the data back into the target's address space to preserve
* endianness.
*/
buffer->d_ino = htog(buffer->d_ino);
buffer->d_off = htog(buffer->d_off);
buffer->d_reclen = htog(buffer->d_reclen);
const ByteOrder bo = tc->getSystemPtr()->getGuestByteOrder();
buffer->d_ino = htog(buffer->d_ino, bo);
buffer->d_off = htog(buffer->d_off, bo);
buffer->d_reclen = htog(buffer->d_reclen, bo);
traversed += host_reclen;
}

129
src/sim/syscall_emul.hh
View File

@@ -538,67 +538,65 @@ getElapsedTimeNano(T1 &sec, T2 &nsec)
template <typename target_stat, typename host_stat>
void
convertStatBuf(target_stat &tgt, host_stat *host, bool fakeTTY = false)
convertStatBuf(target_stat &tgt, host_stat *host,
ByteOrder bo, bool fakeTTY=false)
{
using namespace TheISA;
if (fakeTTY)
tgt->st_dev = 0xA;
else
tgt->st_dev = host->st_dev;
tgt->st_dev = TheISA::htog(tgt->st_dev);
tgt->st_dev = htog(tgt->st_dev, bo);
tgt->st_ino = host->st_ino;
tgt->st_ino = TheISA::htog(tgt->st_ino);
tgt->st_ino = htog(tgt->st_ino, bo);
tgt->st_mode = host->st_mode;
if (fakeTTY) {
// Claim to be a character device
tgt->st_mode &= ~S_IFMT; // Clear S_IFMT
tgt->st_mode |= S_IFCHR; // Set S_IFCHR
}
tgt->st_mode = TheISA::htog(tgt->st_mode);
tgt->st_mode = htog(tgt->st_mode, bo);
tgt->st_nlink = host->st_nlink;
tgt->st_nlink = TheISA::htog(tgt->st_nlink);
tgt->st_nlink = htog(tgt->st_nlink, bo);
tgt->st_uid = host->st_uid;
tgt->st_uid = TheISA::htog(tgt->st_uid);
tgt->st_uid = htog(tgt->st_uid, bo);
tgt->st_gid = host->st_gid;
tgt->st_gid = TheISA::htog(tgt->st_gid);
tgt->st_gid = htog(tgt->st_gid, bo);
if (fakeTTY)
tgt->st_rdev = 0x880d;
else
tgt->st_rdev = host->st_rdev;
tgt->st_rdev = TheISA::htog(tgt->st_rdev);
tgt->st_rdev = htog(tgt->st_rdev, bo);
tgt->st_size = host->st_size;
tgt->st_size = TheISA::htog(tgt->st_size);
tgt->st_size = htog(tgt->st_size, bo);
tgt->st_atimeX = host->st_atime;
tgt->st_atimeX = TheISA::htog(tgt->st_atimeX);
tgt->st_atimeX = htog(tgt->st_atimeX, bo);
tgt->st_mtimeX = host->st_mtime;
tgt->st_mtimeX = TheISA::htog(tgt->st_mtimeX);
tgt->st_mtimeX = htog(tgt->st_mtimeX, bo);
tgt->st_ctimeX = host->st_ctime;
tgt->st_ctimeX = TheISA::htog(tgt->st_ctimeX);
tgt->st_ctimeX = htog(tgt->st_ctimeX, bo);
// Force the block size to be 8KB. This helps to ensure buffered io works
// consistently across different hosts.
tgt->st_blksize = 0x2000;
tgt->st_blksize = TheISA::htog(tgt->st_blksize);
tgt->st_blksize = htog(tgt->st_blksize, bo);
tgt->st_blocks = host->st_blocks;
tgt->st_blocks = TheISA::htog(tgt->st_blocks);
tgt->st_blocks = htog(tgt->st_blocks, bo);
}
// Same for stat64
template <typename target_stat, typename host_stat64>
void
convertStat64Buf(target_stat &tgt, host_stat64 *host, bool fakeTTY = false)
convertStat64Buf(target_stat &tgt, host_stat64 *host,
ByteOrder bo, bool fakeTTY=false)
{
using namespace TheISA;
convertStatBuf<target_stat, host_stat64>(tgt, host, fakeTTY);
convertStatBuf<target_stat, host_stat64>(tgt, host, bo, fakeTTY);
#if defined(STAT_HAVE_NSEC)
tgt->st_atime_nsec = host->st_atime_nsec;
tgt->st_atime_nsec = TheISA::htog(tgt->st_atime_nsec);
tgt->st_atime_nsec = htog(tgt->st_atime_nsec, bo);
tgt->st_mtime_nsec = host->st_mtime_nsec;
tgt->st_mtime_nsec = TheISA::htog(tgt->st_mtime_nsec);
tgt->st_mtime_nsec = htog(tgt->st_mtime_nsec, bo);
tgt->st_ctime_nsec = host->st_ctime_nsec;
tgt->st_ctime_nsec = TheISA::htog(tgt->st_ctime_nsec);
tgt->st_ctime_nsec = htog(tgt->st_ctime_nsec, bo);
#else
tgt->st_atime_nsec = 0;
tgt->st_mtime_nsec = 0;
@@ -614,7 +612,7 @@ copyOutStatBuf(PortProxy &mem, Addr addr,
{
typedef TypedBufferArg<typename OS::tgt_stat> tgt_stat_buf;
tgt_stat_buf tgt(addr);
convertStatBuf<tgt_stat_buf, hst_stat>(tgt, host, fakeTTY);
convertStatBuf<tgt_stat_buf, hst_stat>(tgt, host, OS::byteOrder, fakeTTY);
tgt.copyOut(mem);
}
@@ -625,7 +623,8 @@ copyOutStat64Buf(PortProxy &mem, Addr addr,
{
typedef TypedBufferArg<typename OS::tgt_stat64> tgt_stat_buf;
tgt_stat_buf tgt(addr);
convertStat64Buf<tgt_stat_buf, hst_stat64>(tgt, host, fakeTTY);
convertStat64Buf<tgt_stat_buf, hst_stat64>(
tgt, host, OS::byteOrder, fakeTTY);
tgt.copyOut(mem);
}
@@ -636,27 +635,29 @@ copyOutStatfsBuf(PortProxy &mem, Addr addr,
{
TypedBufferArg<typename OS::tgt_statfs> tgt(addr);
tgt->f_type = TheISA::htog(host->f_type);
const ByteOrder bo = OS::byteOrder;
tgt->f_type = htog(host->f_type, bo);
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
tgt->f_bsize = TheISA::htog(host->f_iosize);
tgt->f_bsize = htog(host->f_iosize, bo);
#else
tgt->f_bsize = TheISA::htog(host->f_bsize);
tgt->f_bsize = htog(host->f_bsize, bo);
#endif
tgt->f_blocks = TheISA::htog(host->f_blocks);
tgt->f_bfree = TheISA::htog(host->f_bfree);
tgt->f_bavail = TheISA::htog(host->f_bavail);
tgt->f_files = TheISA::htog(host->f_files);
tgt->f_ffree = TheISA::htog(host->f_ffree);
tgt->f_blocks = htog(host->f_blocks, bo);
tgt->f_bfree = htog(host->f_bfree, bo);
tgt->f_bavail = htog(host->f_bavail, bo);
tgt->f_files = htog(host->f_files, bo);
tgt->f_ffree = htog(host->f_ffree, bo);
memcpy(&tgt->f_fsid, &host->f_fsid, sizeof(host->f_fsid));
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
tgt->f_namelen = TheISA::htog(host->f_namemax);
tgt->f_frsize = TheISA::htog(host->f_bsize);
tgt->f_namelen = htog(host->f_namemax, bo);
tgt->f_frsize = htog(host->f_bsize, bo);
#elif defined(__APPLE__)
tgt->f_namelen = 0;
tgt->f_frsize = 0;
#else
tgt->f_namelen = TheISA::htog(host->f_namelen);
tgt->f_frsize = TheISA::htog(host->f_frsize);
tgt->f_namelen = htog(host->f_namelen, bo);
tgt->f_frsize = htog(host->f_frsize, bo);
#endif
#if defined(__linux__)
memcpy(&tgt->f_spare, &host->f_spare, sizeof(host->f_spare));
@@ -1679,7 +1680,7 @@ readvFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
for (size_t i = 0; i < count; ++i) {
prox.readBlob(tiov_base + (i * sizeof(typename OS::tgt_iovec)),
&tiov[i], sizeof(typename OS::tgt_iovec));
hiov[i].iov_len = TheISA::gtoh(tiov[i].iov_len);
hiov[i].iov_len = gtoh(tiov[i].iov_len, OS::byteOrder);
hiov[i].iov_base = new char [hiov[i].iov_len];
}
@@ -1688,7 +1689,7 @@ readvFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
for (size_t i = 0; i < count; ++i) {
if (result != -1) {
prox.writeBlob(TheISA::htog(tiov[i].iov_base),
prox.writeBlob(htog(tiov[i].iov_base, OS::byteOrder),
hiov[i].iov_base, hiov[i].iov_len);
}
delete [] (char *)hiov[i].iov_base;
@@ -1720,9 +1721,9 @@ writevFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
prox.readBlob(tiov_base + i*sizeof(typename OS::tgt_iovec),
&tiov, sizeof(typename OS::tgt_iovec));
hiov[i].iov_len = TheISA::gtoh(tiov.iov_len);
hiov[i].iov_len = gtoh(tiov.iov_len, OS::byteOrder);
hiov[i].iov_base = new char [hiov[i].iov_len];
prox.readBlob(TheISA::gtoh(tiov.iov_base), hiov[i].iov_base,
prox.readBlob(gtoh(tiov.iov_base, OS::byteOrder), hiov[i].iov_base,
hiov[i].iov_len);
}
@@ -1955,25 +1956,26 @@ getrlimitFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
unsigned resource = process->getSyscallArg(tc, index);
TypedBufferArg<typename OS::rlimit> rlp(process->getSyscallArg(tc, index));
const ByteOrder bo = OS::byteOrder;
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);
rlp->rlim_cur = htog(rlp->rlim_cur, bo);
rlp->rlim_max = htog(rlp->rlim_max, bo);
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);
rlp->rlim_cur = htog(rlp->rlim_cur, bo);
rlp->rlim_max = htog(rlp->rlim_max, bo);
break;
case OS::TGT_RLIMIT_NPROC:
rlp->rlim_cur = rlp->rlim_max = tc->getSystemPtr()->numContexts();
rlp->rlim_cur = TheISA::htog(rlp->rlim_cur);
rlp->rlim_max = TheISA::htog(rlp->rlim_max);
rlp->rlim_cur = htog(rlp->rlim_cur, bo);
rlp->rlim_max = htog(rlp->rlim_max, bo);
break;
default:
@@ -2002,21 +2004,22 @@ prlimitFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
if (n != 0)
warn("prlimit: ignoring new rlimit");
Addr o = process->getSyscallArg(tc, index);
if (o != 0)
{
if (o != 0) {
const ByteOrder bo = OS::byteOrder;
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);
rlp->rlim_cur = htog(rlp->rlim_cur, bo);
rlp->rlim_max = htog(rlp->rlim_max, bo);
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);
rlp->rlim_cur = htog(rlp->rlim_cur, bo);
rlp->rlim_max = htog(rlp->rlim_max, bo);
break;
default:
warn("prlimit: unimplemented resource %d", resource);
@@ -2040,8 +2043,8 @@ clock_gettimeFunc(SyscallDesc *desc, int num, ThreadContext *tc)
getElapsedTimeNano(tp->tv_sec, tp->tv_nsec);
tp->tv_sec += seconds_since_epoch;
tp->tv_sec = TheISA::htog(tp->tv_sec);
tp->tv_nsec = TheISA::htog(tp->tv_nsec);
tp->tv_sec = htog(tp->tv_sec, OS::byteOrder);
tp->tv_nsec = htog(tp->tv_nsec, OS::byteOrder);
tp.copyOut(tc->getVirtProxy());
@@ -2077,8 +2080,8 @@ gettimeofdayFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
getElapsedTimeMicro(tp->tv_sec, tp->tv_usec);
tp->tv_sec += seconds_since_epoch;
tp->tv_sec = TheISA::htog(tp->tv_sec);
tp->tv_usec = TheISA::htog(tp->tv_usec);
tp->tv_sec = htog(tp->tv_sec, OS::byteOrder);
tp->tv_usec = htog(tp->tv_usec, OS::byteOrder);
tp.copyOut(tc->getVirtProxy());
@@ -2106,8 +2109,8 @@ utimesFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
struct timeval hostTimeval[2];
for (int i = 0; i < 2; ++i) {
hostTimeval[i].tv_sec = TheISA::gtoh((*tp)[i].tv_sec);
hostTimeval[i].tv_usec = TheISA::gtoh((*tp)[i].tv_usec);
hostTimeval[i].tv_sec = gtoh((*tp)[i].tv_sec, OS::byteOrder);
hostTimeval[i].tv_usec = gtoh((*tp)[i].tv_usec, OS::byteOrder);
}
// Adjust path for cwd and redirection
@@ -2245,8 +2248,8 @@ getrusageFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
switch (who) {
case OS::TGT_RUSAGE_SELF:
getElapsedTimeMicro(rup->ru_utime.tv_sec, rup->ru_utime.tv_usec);
rup->ru_utime.tv_sec = TheISA::htog(rup->ru_utime.tv_sec);
rup->ru_utime.tv_usec = TheISA::htog(rup->ru_utime.tv_usec);
rup->ru_utime.tv_sec = htog(rup->ru_utime.tv_sec, OS::byteOrder);
rup->ru_utime.tv_usec = htog(rup->ru_utime.tv_usec, OS::byteOrder);
break;
case OS::TGT_RUSAGE_CHILDREN:
@@ -2282,7 +2285,7 @@ timesFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
bufp->tms_cstime = 0;
// Convert to host endianness
bufp->tms_utime = TheISA::htog(bufp->tms_utime);
bufp->tms_utime = htog(bufp->tms_utime, OS::byteOrder);
// Write back
bufp.copyOut(tc->getVirtProxy());
@@ -2305,7 +2308,7 @@ timeFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
Addr taddr = (Addr)process->getSyscallArg(tc, index);
if (taddr != 0) {
typename OS::time_t t = sec;
t = TheISA::htog(t);
t = htog(t, OS::byteOrder);
PortProxy &p = tc->getVirtProxy();
p.writeBlob(taddr, &t, (int)sizeof(typename OS::time_t));
}