Premier commit

Cette révision appartient à :
Théo Gastinel a révisé 2026-10-11 01:55:22 +02:00
révision 536792a769
62 fichiers modifiés
+6766

Aucun fichier ne correspond à votre recherche

+91
Voir le fichier
@@ -0,0 +1,91 @@
// 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