// 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(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; }