92 lignes
3.1 KiB
C++
92 lignes
3.1 KiB
C++
// mem/page_source_host.cpp — acquisition des pages sur la machine de dev.
|
|
//
|
|
// CIBLE HOTE UNIQUEMENT. Utilise malloc, ce qui serait inacceptable sur la
|
|
// cible embarquee. C est l asymetrie assumee de l ADR-0001.
|
|
//
|
|
// Le mode rendu est toujours HugeMode::HostEmulated, precisement pour qu il
|
|
// soit impossible de prendre une mesure faite ici pour une mesure faite sur
|
|
// le telephone. Ce n est pas un detail cosmetique : c est la seule protection
|
|
// contre la publication d un chiffre obtenu sur un x86 de bureau.
|
|
//
|
|
// Le malloc utilise ici est appele AVANT que le garde-fou d allocation ne
|
|
// puisse intervenir, et il passe par malloc et non par operator new : les deux
|
|
// mecanismes sont distincts, le garde-fou n intercepte que operator new.
|
|
// C est voulu. Cf. mem/new_guard.cpp, section "Ce que le garde-fou n attrape
|
|
// pas".
|
|
#include "proj3/mem/page_source.hpp"
|
|
|
|
#include <cstdlib>
|
|
|
|
#include "proj3/mem/layout.hpp"
|
|
#include "proj3/sys/panic.hpp"
|
|
|
|
namespace proj3::mem {
|
|
namespace {
|
|
|
|
HugeMode g_active = HugeMode::Uninitialized;
|
|
|
|
// On garde le pointeur brut rendu par malloc pour pouvoir le liberer, puisque
|
|
// la base publiee est alignee et donc potentiellement decalee.
|
|
void* g_raw = nullptr;
|
|
|
|
} // namespace
|
|
|
|
const char* huge_mode_name(HugeMode m) {
|
|
switch (m) {
|
|
case HugeMode::Hugetlb2MB: return "HUGETLB-2MB";
|
|
case HugeMode::TransparentHuge: return "THP-MADV_HUGEPAGE";
|
|
case HugeMode::PlainPages: return "PAGES-4K";
|
|
case HugeMode::HostEmulated: return "HOTE-EMULE";
|
|
case HugeMode::Uninitialized: break;
|
|
}
|
|
return "NON-INITIALISE";
|
|
}
|
|
|
|
bool page_acquire(usize size, PageBlock& out) {
|
|
out = PageBlock{};
|
|
if (size == 0 || (size % kHugePageSize) != 0) {
|
|
panic_v("page_acquire : taille non multiple de 2 Mo", "taille",
|
|
static_cast<i64>(size));
|
|
}
|
|
if (g_raw != nullptr) {
|
|
panic("page_acquire hote : une seule acquisition a la fois");
|
|
}
|
|
|
|
// Alignement manuel sur 2 Mo : on veut que la disposition memoire vue par
|
|
// les arenes soit la meme que sur la cible, sinon un bug d alignement ne
|
|
// se manifesterait que sur le telephone.
|
|
void* raw = std::malloc(size + kHugePageSize);
|
|
if (raw == nullptr) return false;
|
|
g_raw = raw;
|
|
|
|
const uptr addr = reinterpret_cast<uptr>(raw);
|
|
const uptr aligned = (addr + (kHugePageSize - 1)) & ~static_cast<uptr>(kHugePageSize - 1);
|
|
|
|
out.base = reinterpret_cast<u8*>(aligned);
|
|
out.size = size;
|
|
out.mode = HugeMode::HostEmulated;
|
|
g_active = out.mode;
|
|
return true;
|
|
}
|
|
|
|
void page_release(PageBlock& block) {
|
|
if (g_raw != nullptr) {
|
|
std::free(g_raw);
|
|
g_raw = nullptr;
|
|
}
|
|
block = PageBlock{};
|
|
}
|
|
|
|
HugeMode active_mode() { return g_active; }
|
|
|
|
void log_active_mode() {
|
|
err_write("proj3: memoire : mode retenu = ");
|
|
err_write(huge_mode_name(g_active));
|
|
err_write("\n");
|
|
err_write("proj3: memoire : CIBLE HOTE. Aucune propriete de determinisme.\n");
|
|
err_write("proj3: memoire : ce mode sert a valider la CORRECTION, jamais\n");
|
|
err_write("proj3: memoire : la latence. Ne publier aucun chiffre d ici.\n");
|
|
}
|
|
|
|
} // namespace proj3::mem
|