// 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 #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(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(raw); const uptr aligned = (addr + (kHugePageSize - 1)) & ~static_cast(kHugePageSize - 1); out.base = reinterpret_cast(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