#include "Gigacage.h"
#include "CryptoRandom.h"
#include "Environment.h"
#include "PerProcess.h"
#include "ProcessCheck.h"
#include "VMAllocate.h"
#include "Vector.h"
#include "bmalloc.h"
#include <cstdio>
#include <mutex>
#if GIGACAGE_ENABLED
namespace Gigacage {
constexpr size_t gigacageRunway = 32llu * 1024 * 1024 * 1024;
alignas(gigacageBasePtrsSize) char g_gigacageBasePtrs[gigacageBasePtrsSize];
using namespace bmalloc;
namespace {
bool s_isDisablingPrimitiveGigacageDisabled;
void protectGigacageBasePtrs()
{
uintptr_t basePtrs = reinterpret_cast<uintptr_t>(g_gigacageBasePtrs);
RELEASE_BASSERT(!(basePtrs & (vmPageSize() - 1)));
mprotect(g_gigacageBasePtrs, gigacageBasePtrsSize, PROT_READ);
}
void unprotectGigacageBasePtrs()
{
mprotect(g_gigacageBasePtrs, gigacageBasePtrsSize, PROT_READ | PROT_WRITE);
}
class UnprotectGigacageBasePtrsScope {
public:
UnprotectGigacageBasePtrsScope()
{
unprotectGigacageBasePtrs();
}
~UnprotectGigacageBasePtrsScope()
{
protectGigacageBasePtrs();
}
};
struct Callback {
Callback() { }
Callback(void (*function)(void*), void *argument)
: function(function)
, argument(argument)
{
}
void (*function)(void*) { nullptr };
void* argument { nullptr };
};
struct PrimitiveDisableCallbacks {
PrimitiveDisableCallbacks(std::lock_guard<Mutex>&) { }
Vector<Callback> callbacks;
};
size_t runwaySize(Kind kind)
{
switch (kind) {
case Kind::ReservedForFlagsAndNotABasePtr:
RELEASE_BASSERT_NOT_REACHED();
case Kind::Primitive:
return gigacageRunway;
case Kind::JSValue:
return 0;
}
return 0;
}
}
void ensureGigacage()
{
static std::once_flag onceFlag;
std::call_once(
onceFlag,
[] {
if (!shouldBeEnabled())
return;
Kind shuffledKinds[numKinds];
for (unsigned i = 0; i < numKinds; ++i)
shuffledKinds[i] = static_cast<Kind>(i + 1);
static_assert(numKinds <= 21, "too many kinds");
uint64_t random;
cryptoRandom(reinterpret_cast<unsigned char*>(&random), sizeof(random));
for (unsigned i = numKinds; i--;) {
unsigned limit = i + 1;
unsigned j = static_cast<unsigned>(random % limit);
random /= limit;
std::swap(shuffledKinds[i], shuffledKinds[j]);
}
auto alignTo = [] (Kind kind, size_t totalSize) -> size_t {
return roundUpToMultipleOf(alignment(kind), totalSize);
};
auto bump = [] (Kind kind, size_t totalSize) -> size_t {
return totalSize + size(kind);
};
size_t totalSize = 0;
size_t maxAlignment = 0;
for (Kind kind : shuffledKinds) {
totalSize = bump(kind, alignTo(kind, totalSize));
totalSize += runwaySize(kind);
maxAlignment = std::max(maxAlignment, alignment(kind));
}
void* base = tryVMAllocate(maxAlignment, totalSize);
if (!base) {
if (GIGACAGE_ALLOCATION_CAN_FAIL)
return;
fprintf(stderr, "FATAL: Could not allocate gigacage memory with maxAlignment = %lu, totalSize = %lu.\n", maxAlignment, totalSize);
fprintf(stderr, "(Make sure you have not set a virtual memory limit.)\n");
BCRASH();
}
size_t nextCage = 0;
for (Kind kind : shuffledKinds) {
nextCage = alignTo(kind, nextCage);
basePtr(kind) = reinterpret_cast<char*>(base) + nextCage;
nextCage = bump(kind, nextCage);
if (runwaySize(kind) > 0) {
char* runway = reinterpret_cast<char*>(base) + nextCage;
vmRevokePermissions(runway, runwaySize(kind));
nextCage += runwaySize(kind);
}
}
vmDeallocatePhysicalPages(base, totalSize);
setWasEnabled();
protectGigacageBasePtrs();
});
}
void disablePrimitiveGigacage()
{
ensureGigacage();
if (!basePtrs().primitive) {
return;
}
PrimitiveDisableCallbacks& callbacks = *PerProcess<PrimitiveDisableCallbacks>::get();
std::unique_lock<Mutex> lock(PerProcess<PrimitiveDisableCallbacks>::mutex());
for (Callback& callback : callbacks.callbacks)
callback.function(callback.argument);
callbacks.callbacks.shrink(0);
UnprotectGigacageBasePtrsScope unprotectScope;
basePtrs().primitive = nullptr;
}
void addPrimitiveDisableCallback(void (*function)(void*), void* argument)
{
ensureGigacage();
if (!basePtrs().primitive) {
function(argument);
return;
}
PrimitiveDisableCallbacks& callbacks = *PerProcess<PrimitiveDisableCallbacks>::get();
std::unique_lock<Mutex> lock(PerProcess<PrimitiveDisableCallbacks>::mutex());
callbacks.callbacks.push(Callback(function, argument));
}
void removePrimitiveDisableCallback(void (*function)(void*), void* argument)
{
PrimitiveDisableCallbacks& callbacks = *PerProcess<PrimitiveDisableCallbacks>::get();
std::unique_lock<Mutex> lock(PerProcess<PrimitiveDisableCallbacks>::mutex());
for (size_t i = 0; i < callbacks.callbacks.size(); ++i) {
if (callbacks.callbacks[i].function == function
&& callbacks.callbacks[i].argument == argument) {
callbacks.callbacks[i] = callbacks.callbacks.last();
callbacks.callbacks.pop();
return;
}
}
}
static void primitiveGigacageDisabled(void*)
{
if (GIGACAGE_ALLOCATION_CAN_FAIL && !wasEnabled())
return;
static bool s_false;
fprintf(stderr, "FATAL: Primitive gigacage disabled, but we don't want that in this process.\n");
if (!s_false)
BCRASH();
}
void disableDisablingPrimitiveGigacageIfShouldBeEnabled()
{
if (shouldBeEnabled()) {
addPrimitiveDisableCallback(primitiveGigacageDisabled, nullptr);
s_isDisablingPrimitiveGigacageDisabled = true;
}
}
bool isDisablingPrimitiveGigacageDisabled()
{
return s_isDisablingPrimitiveGigacageDisabled;
}
bool shouldBeEnabled()
{
static bool cached = false;
static std::once_flag onceFlag;
std::call_once(
onceFlag,
[] {
if (!gigacageEnabledForProcess())
return;
bool result = !PerProcess<Environment>::get()->isDebugHeapEnabled();
if (!result)
return;
if (char* gigacageEnabled = getenv("GIGACAGE_ENABLED")) {
if (!strcasecmp(gigacageEnabled, "no") || !strcasecmp(gigacageEnabled, "false") || !strcasecmp(gigacageEnabled, "0")) {
fprintf(stderr, "Warning: disabling gigacage because GIGACAGE_ENABLED=%s!\n", gigacageEnabled);
return;
} else if (strcasecmp(gigacageEnabled, "yes") && strcasecmp(gigacageEnabled, "true") && strcasecmp(gigacageEnabled, "1"))
fprintf(stderr, "Warning: invalid argument to GIGACAGE_ENABLED: %s\n", gigacageEnabled);
}
cached = true;
});
return cached;
}
}
#endif // GIGACAGE_ENABLED