264 lignes
11 KiB
C++
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;
|
|
}
|