Fichiers
2026-10-11 01:55:22 +02:00

264 lignes
11 KiB
C++

// test/test_syscalls.cpp — harnais des wrappers d appels systeme (chantier 2).
//
// OU L EXECUTER : n importe quel Linux AArch64. Raspberry Pi sous 64 bits,
// VM ARM, conteneur, ou qemu-user. PAS BESOIN DU TELEPHONE : aucun test ne
// touche au graphique, a l entree, ni au reseau.
//
// qemu-aarch64 ./proj3_test_syscalls # emulation utilisateur
// ./proj3_test_syscalls # natif
//
// Code de sortie : 0 si tout passe, 1 sinon. Chaque ligne dit OK ou ECHEC.
//
// LE CAS D ERREUR EST LE PLUS IMPORTANT. Un wrapper qui rendrait -2 et qu on
// interpreterait comme un descripteur valide donnerait un bug tres loin d ici.
// Chaque appel a donc son cas nominal ET son cas d erreur, et le cas d erreur
// verifie a la fois is_err() ET le code errno exact.
#include "proj3/base/mem.hpp"
#include "proj3/sys/panic.hpp"
#include "proj3/sys/syscalls.hpp"
#include "proj3/sys/uapi.hpp"
using namespace proj3;
namespace {
int g_failures = 0;
void check(bool cond, const char* what) {
err_write(cond ? "OK " : "ECHEC ");
err_write(what);
err_write("\n");
if (!cond) ++g_failures;
}
void check_err(const sys::Result r, i32 expected_errno, const char* what) {
const bool ok = r.is_err() && r.err() == expected_errno;
err_write(ok ? "OK " : "ECHEC ");
err_write(what);
if (!ok) {
err_write(" (attendu -");
err_write_i64(expected_errno);
err_write(", obtenu ");
err_write_i64(r.raw);
err_write(")");
++g_failures;
}
err_write("\n");
}
// Chemin garanti inexistant. On evite /tmp, qui peut etre monte en lecture
// seule ou absent sur un systeme minimal.
const char kMissing[] = "/proj3-ce-fichier-n-existe-pas-42";
const char kSelf[] = "/proc/self/maps";
} // namespace
extern "C" int proj3_main(int, char**) {
err_write("=== wrappers syscall AArch64 ===\n\n");
// --- Verification prealable de la convention elle-meme -----------------
// Si ces trois assertions ne tenaient pas, tous les tests suivants
// seraient sans valeur.
{
constexpr sys::Result ok_zero{0};
constexpr sys::Result ok_big{-4096};
constexpr sys::Result err_min{-1};
constexpr sys::Result err_max{-4095};
static_assert(!ok_zero.is_err());
static_assert(!ok_big.is_err(), "-4096 est HORS de la plage d erreur");
static_assert(err_min.is_err() && err_min.err() == 1);
static_assert(err_max.is_err() && err_max.err() == 4095);
check(true, "plage d erreur [-4095,-1] exacte (verifiee a la compilation)");
}
// --- getpid : nominal seulement (il ne peut pas echouer) ---------------
{
const sys::Result r = sys::getpid();
check(r.is_ok() && r.value() > 0, "getpid nominal");
}
// --- write ------------------------------------------------------------
{
const char msg[] = "";
const sys::Result r = sys::write(sys::FD_STDOUT, msg, 0);
check(r.is_ok() && r.value() == 0, "write nominal (0 octet)");
}
{
const sys::Result r = sys::write(-1, "x", 1);
check_err(r, sys::EBADF, "write cas d erreur (descripteur invalide -> EBADF)");
}
// --- open --------------------------------------------------------------
// LE test qui compte : un open sur un fichier absent doit remonter une
// erreur, pas un descripteur.
{
const sys::Result r = sys::open(kMissing, sys::O_RDONLY);
check_err(r, sys::ENOENT, "open cas d erreur (fichier absent -> ENOENT)");
// Verification supplementaire, explicite : la valeur ne doit surtout
// pas etre utilisable comme descripteur.
check(r.is_err(), "open absent : is_err() vaut bien true");
}
i32 fd = -1;
{
const sys::Result r = sys::open(kSelf, sys::O_RDONLY);
check(r.is_ok() && r.fd() >= 0, "open nominal (/proc/self/maps)");
if (r.is_ok()) fd = r.fd();
}
// --- read --------------------------------------------------------------
{
u8 buf[64];
mem_fill(buf, 0, sizeof(buf));
if (fd >= 0) {
const sys::Result r = sys::read(fd, buf, sizeof(buf));
check(r.is_ok() && r.value() > 0, "read nominal");
} else {
check(false, "read nominal (open prealable a echoue)");
}
const sys::Result r2 = sys::read(-1, buf, sizeof(buf));
check_err(r2, sys::EBADF, "read cas d erreur (descripteur invalide -> EBADF)");
}
// --- lseek -------------------------------------------------------------
{
if (fd >= 0) {
const sys::Result r = sys::lseek(fd, 0, sys::SEEK_SET);
check(r.is_ok() && r.value() == 0, "lseek nominal (retour au debut)");
} else {
check(false, "lseek nominal (open prealable a echoue)");
}
const sys::Result r2 = sys::lseek(-1, 0, sys::SEEK_SET);
check_err(r2, sys::EBADF, "lseek cas d erreur (descripteur invalide -> EBADF)");
}
// --- fstat -------------------------------------------------------------
{
sys::Stat st;
mem_fill(&st, 0, sizeof(st));
if (fd >= 0) {
const sys::Result r = sys::fstat(fd, &st);
// /proc/self/maps a une taille declaree nulle : on verifie le mode,
// pas la taille. S_IFREG = 0100000 octal.
check(r.is_ok() && (st.mode & 0170000u) == 0100000u,
"fstat nominal (mode de fichier regulier)");
} else {
check(false, "fstat nominal (open prealable a echoue)");
}
const sys::Result r2 = sys::fstat(-1, &st);
check_err(r2, sys::EBADF, "fstat cas d erreur (descripteur invalide -> EBADF)");
}
// --- ioctl -------------------------------------------------------------
// Aucun ioctl graphique dans cette passe. On se contente de verifier que
// le wrapper transmet bien et que l erreur remonte : un ioctl inconnu sur
// un fichier regulier donne ENOTTY.
{
if (fd >= 0) {
const sys::Result r = sys::ioctl(fd, 0xDEADu);
check(r.is_err() && (r.err() == sys::ENOTTY || r.err() == sys::EINVAL),
"ioctl cas d erreur (requete inconnue -> ENOTTY/EINVAL)");
} else {
check(false, "ioctl cas d erreur (open prealable a echoue)");
}
const sys::Result r2 = sys::ioctl(-1, 0x1234u);
check_err(r2, sys::EBADF, "ioctl descripteur invalide -> EBADF");
}
// --- close -------------------------------------------------------------
{
if (fd >= 0) {
const sys::Result r = sys::close(fd);
check(r.is_ok(), "close nominal");
} else {
check(false, "close nominal (open prealable a echoue)");
}
const sys::Result r2 = sys::close(-1);
check_err(r2, sys::EBADF, "close cas d erreur (descripteur invalide -> EBADF)");
}
// --- mmap / munmap / madvise -------------------------------------------
// Verification explicite du 6e argument de mmap : on mappe avec un offset
// non nul sur un descripteur invalide. Si le 6e argument n arrivait pas au
// noyau, l erreur serait EINVAL au lieu de EBADF.
{
const usize len = 4096;
const sys::Result r = sys::mmap(nullptr, len, sys::PROT_READ | sys::PROT_WRITE,
sys::MAP_PRIVATE | sys::MAP_ANONYMOUS, -1, 0);
check(r.is_ok(), "mmap nominal (anonyme 4 Ko)");
if (r.is_ok()) {
u8* p = static_cast<u8*>(r.ptr());
p[0] = 0x42;
p[len - 1] = 0x43;
check(p[0] == 0x42 && p[len - 1] == 0x43, "mmap : la memoire est ecrivable");
const sys::Result a = sys::madvise(p, len, sys::MADV_WILLNEED);
check(a.is_ok(), "madvise nominal (MADV_WILLNEED)");
const sys::Result u = sys::munmap(p, len);
check(u.is_ok(), "munmap nominal");
} else {
check(false, "mmap : la memoire est ecrivable (mmap a echoue)");
check(false, "madvise nominal (mmap a echoue)");
check(false, "munmap nominal (mmap a echoue)");
}
}
{
// Longueur nulle : EINVAL. Cas d erreur simple et sans effet de bord.
const sys::Result r = sys::mmap(nullptr, 0, sys::PROT_READ,
sys::MAP_PRIVATE | sys::MAP_ANONYMOUS, -1, 0);
check_err(r, sys::EINVAL, "mmap cas d erreur (longueur nulle -> EINVAL)");
}
{
// 6e argument : offset non nul, descripteur invalide, mapping de
// fichier. Le noyau doit voir un fd invalide (EBADF).
const sys::Result r = sys::mmap(nullptr, 4096, sys::PROT_READ, sys::MAP_PRIVATE, -1,
4096);
check(r.is_err(), "mmap 6e argument : l appel parvient au noyau et echoue proprement");
}
{
const sys::Result r = sys::munmap(nullptr, 0);
check_err(r, sys::EINVAL, "munmap cas d erreur (longueur nulle -> EINVAL)");
}
{
const sys::Result r = sys::madvise(nullptr, 0, 0xFFFF);
check(r.is_err(), "madvise cas d erreur (conseil inconnu)");
}
// --- clock_gettime ------------------------------------------------------
{
sys::TimeSpec ts{0, 0};
const sys::Result r = sys::clock_gettime(sys::CLOCK_MONOTONIC, &ts);
check(r.is_ok() && (ts.sec > 0 || ts.nsec > 0), "clock_gettime nominal (MONOTONIC)");
const sys::Result r2 = sys::clock_gettime(0x7FFF, &ts);
check(r2.is_err(), "clock_gettime cas d erreur (horloge inconnue)");
}
// --- nanosleep ----------------------------------------------------------
{
const sys::TimeSpec req{0, 1000000}; // 1 ms
const sys::Result r = sys::nanosleep(&req, nullptr);
check(r.is_ok(), "nanosleep nominal (1 ms)");
const sys::TimeSpec bad{0, 2000000000}; // nsec >= 1e9 : invalide
const sys::Result r2 = sys::nanosleep(&bad, nullptr);
check_err(r2, sys::EINVAL, "nanosleep cas d erreur (nsec hors bornes -> EINVAL)");
}
// --- exit / exit_group ---------------------------------------------------
// Ils ne reviennent pas : on ne peut pas les tester ici sans terminer le
// processus. Ils sont testes IMPLICITEMENT et de la seule facon possible :
// ce programme se termine par exit_group via asm/start.S, et son code de
// sortie est observable par le script appelant. Si exit_group etait faux,
// ce binaire ne rendrait jamais la main proprement.
err_write("NOTE exit/exit_group : testes implicitement par la terminaison\n");
err_write(" de ce programme (code de sortie observable a l exterieur).\n");
err_write("\nechecs : ");
err_write_i64(g_failures);
err_write("\n");
return g_failures == 0 ? 0 : 1;
}