mirror of
https://github.com/FEX-Emu/FEX.git
synced 2026-10-11 21:00:40 +02:00
Ryan Houdek
cc8fa9d934
This was altered in kernel 2.3.23 to include a mem_unit variable. mem_unit states what each of the memory units is scaled by. The kernel will always have this be 1 or page size on x86, so follow that behaviour. Instead of maxing out the values to what uint32_t can handle, scale all of these by page size instead. This fixes a crash in KOTOR2's boot sequence where it would divide by zero if everything was maxed out.
92 lines
2.8 KiB
C++
92 lines
2.8 KiB
C++
/*
|
|
$info$
|
|
tags: LinuxSyscalls|syscalls-x86-32
|
|
$end_info$
|
|
*/
|
|
|
|
#include "Tests/LinuxSyscalls/Syscalls.h"
|
|
#include "Tests/LinuxSyscalls/x32/Syscalls.h"
|
|
|
|
#include <sys/resource.h>
|
|
#include <sys/utsname.h>
|
|
#include <sys/sysinfo.h>
|
|
|
|
namespace FEX::HLE::x32 {
|
|
struct rlimit32 {
|
|
uint32_t rlim_cur;
|
|
uint32_t rlim_max;
|
|
};
|
|
|
|
struct sysinfo32 {
|
|
int32_t uptime;
|
|
uint32_t loads[3];
|
|
uint32_t totalram;
|
|
uint32_t freeram;
|
|
uint32_t sharedram;
|
|
uint32_t bufferram;
|
|
uint32_t totalswap;
|
|
uint32_t freeswap;
|
|
uint16_t procs;
|
|
uint32_t totalhigh;
|
|
uint32_t freehigh;
|
|
uint32_t mem_unit;
|
|
char _pad[8];
|
|
};
|
|
|
|
static_assert(sizeof(sysinfo32) == 64, "Needs to be 64bytes");
|
|
|
|
void RegisterInfo() {
|
|
REGISTER_SYSCALL_IMPL_X32(ugetrlimit, [](FEXCore::Core::CpuStateFrame *Frame, int resource, rlimit32 *rlim) -> uint64_t {
|
|
struct rlimit rlim64{};
|
|
uint64_t Result = ::getrlimit(resource, &rlim64);
|
|
rlim->rlim_cur = rlim64.rlim_cur;
|
|
rlim->rlim_max = rlim64.rlim_max;
|
|
SYSCALL_ERRNO();
|
|
});
|
|
|
|
REGISTER_SYSCALL_IMPL_X32(sysinfo, [](FEXCore::Core::CpuStateFrame *Frame, struct sysinfo32 *info) -> uint64_t {
|
|
struct sysinfo Host{};
|
|
uint64_t Result = ::sysinfo(&Host);
|
|
if (Result != -1) {
|
|
#define Copy(x) info->x = static_cast<decltype(info->x)>(std::min(Host.x, static_cast<decltype(Host.x)>(std::numeric_limits<decltype(info->x)>::max())));
|
|
Copy(uptime);
|
|
Copy(procs);
|
|
#define CopyShift(x) info->x = static_cast<decltype(info->x)>(Host.x >> ShiftAmount);
|
|
|
|
info->loads[0] = std::min(Host.loads[0], static_cast<unsigned long>(std::numeric_limits<uint32_t>::max()));
|
|
info->loads[1] = std::min(Host.loads[1], static_cast<unsigned long>(std::numeric_limits<uint32_t>::max()));
|
|
info->loads[2] = std::min(Host.loads[2], static_cast<unsigned long>(std::numeric_limits<uint32_t>::max()));
|
|
|
|
// If any result can't fit in to a uint32_t then we need to shift the mem_unit and all the members
|
|
// Set the mem_unit to the pagesize
|
|
uint32_t ShiftAmount{};
|
|
if ((Host.totalram >> 32) != 0 ||
|
|
(Host.totalswap >> 32) != 0) {
|
|
|
|
while (Host.mem_unit < 4096) {
|
|
Host.mem_unit <<= 1;
|
|
++ShiftAmount;
|
|
}
|
|
}
|
|
|
|
CopyShift(totalram);
|
|
CopyShift(sharedram);
|
|
CopyShift(bufferram);
|
|
CopyShift(totalswap);
|
|
CopyShift(freeswap);
|
|
CopyShift(totalhigh);
|
|
CopyShift(freehigh);
|
|
Copy(mem_unit);
|
|
}
|
|
SYSCALL_ERRNO();
|
|
});
|
|
|
|
REGISTER_SYSCALL_IMPL_X32(getrusage, [](FEXCore::Core::CpuStateFrame *Frame, int who, rusage_32 *usage) -> uint64_t {
|
|
struct rusage usage64 = *usage;
|
|
uint64_t Result = ::getrusage(who, &usage64);
|
|
*usage = usage64;
|
|
SYSCALL_ERRNO();
|
|
});
|
|
}
|
|
}
|