air_sys_syscall/

arch.rs

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

//! Syscalls **spécifiques à l'architecture** — `arch_prctl(2)` (ADR-051).
//!
//! `arch_prctl` n'existe **que sur x86_64** : il programme la base des registres
//! de segment `%fs`/`%gs`. Air l'utilise pour fixer le registre TLS du **thread
//! principal** (`%fs`) au démarrage (`air-rt`, ADR-049 D2). Sur **aarch64**, le
//! registre TLS (`tpidr_el0`) est inscriptible directement en EL0 par une
//! instruction `msr` (affaire d'`air-rt`, pas un syscall) ; ce module est donc
//! **vide** sur aarch64. Les threads **spawnés** (toutes arches) reçoivent leur
//! registre TLS du kernel via `CLONE_SETTLS` ([`crate::process::clone_thread`]).
//!
//! Conformément à ADR-021 §3 (pas de wrapper multiplexé), `arch_prctl` est
//! exposé par des fonctions **dédiées** [`set_fs`]/[`get_fs`], jamais par un
//! `arch_prctl(op, …)` générique.

#[cfg(target_arch = "x86_64")]
use air_sys_types::Errno;
#[cfg(target_arch = "x86_64")]
use core::num::NonZeroI32;

/// `ARCH_SET_FS` (cf. `asm/prctl.h`).
#[cfg(target_arch = "x86_64")]
const ARCH_SET_FS: i64 = 0x1002;
/// `ARCH_GET_FS` (cf. `asm/prctl.h`).
#[cfg(target_arch = "x86_64")]
const ARCH_GET_FS: i64 = 0x1003;

/// Fixe la base du registre de segment `%fs` (registre TLS) du thread appelant.
///
/// Sert à `air-rt` pour ancrer le **TCB** du thread principal au registre TLS
/// (ADR-049 D1/D2). N'existe **que sur x86_64**.
///
/// # Safety
///
/// **Hautement `unsafe`.** Après cet appel, **tout accès `thread_local`** du
/// thread (y compris ceux insérés par le compilateur / la bibliothèque standard
/// si elle est liée) résout via `base`. L'appelant doit garantir que `base`
/// pointe une **image TLS valide et correctement initialisée** pour ce thread
/// (sinon corruption mémoire silencieuse de tout l'état par-thread). Passer une
/// base erronée est un comportement indéfini du programme, pas seulement de
/// cette fonction.
///
/// # Errors
///
/// - [`Errno::EINVAL`] / [`Errno::EPERM`] : `base` rejetée par le kernel (p. ex.
///   adresse **non canonique**). Dans ce cas le kernel **ne modifie pas** `%fs`.
#[cfg(target_arch = "x86_64")]
pub unsafe fn set_fs(base: usize) -> Result<(), Errno> {
    let ret: i64;
    // SAFETY:
    // - SYS_arch_prctl (x86_64 = 158) avec ARCH_SET_FS programme la base de
    //   `%fs` sur `base`. La validité de `base` (image TLS valide) relève du
    //   contrat `unsafe` ci-dessus.
    // - L'ABI syscall x86_64 : numéro en RAX, args en RDI/RSI, retour en RAX,
    //   clobbe RCX (RIP) et R11 (RFLAGS).
    // - **Pas** d'option `readonly`/`pure` : l'effet sur `%fs` change la
    //   sémantique des accès TLS suivants ; on interdit donc au compilateur de
    //   réordonner librement autour de l'asm (barrière conservatrice).
    unsafe {
        core::arch::asm!(
            "syscall",
            in("rax") 158_i64,
            in("rdi") ARCH_SET_FS,
            in("rsi") base,
            lateout("rax") ret,
            lateout("rcx") _,
            lateout("r11") _,
            options(nostack),
        );
    }
    if ret < 0 {
        return Err(errno_from_negative_syscall_ret(ret));
    }
    Ok(())
}

/// Lit la base courante du registre de segment `%fs` (registre TLS) du thread
/// appelant. N'existe **que sur x86_64**. Opération **sûre** (lecture seule).
///
/// # Errors
///
/// - [`Errno`] propagée si le kernel rejette l'appel (ne devrait pas survenir
///   sur un kernel conforme).
#[cfg(target_arch = "x86_64")]
pub fn get_fs() -> Result<usize, Errno> {
    let mut base: usize = 0;
    let ret: i64;
    // SAFETY:
    // - SYS_arch_prctl (x86_64 = 158) avec ARCH_GET_FS écrit la base courante de
    //   `%fs` à l'adresse fournie en RSI (`&mut base`, mémoire locale valide).
    // - Absence d'option `readonly` : l'asm **écrit** la mémoire pointée par
    //   RSI, donc `base` est correctement considéré comme modifié après l'appel.
    // - Clobbers RCX/R11 comme tout `syscall` x86_64.
    unsafe {
        core::arch::asm!(
            "syscall",
            in("rax") 158_i64,
            in("rdi") ARCH_GET_FS,
            in("rsi") &mut base,
            lateout("rax") ret,
            lateout("rcx") _,
            lateout("r11") _,
            options(nostack),
        );
    }
    if ret < 0 {
        return Err(errno_from_negative_syscall_ret(ret));
    }
    Ok(base)
}

/// Convertit un retour de syscall strictement négatif en [`Errno`]. Copie locale
/// du helper (convention couche 0 : un helper privé par module).
#[cfg(target_arch = "x86_64")]
fn errno_from_negative_syscall_ret(ret: i64) -> Errno {
    debug_assert!(ret < 0 && ret > -4096);
    #[allow(clippy::cast_possible_truncation)]
    let raw = ret.wrapping_neg() as i32;
    let nz = NonZeroI32::new(raw).expect("errno strictement positif par construction");
    Errno::from_nonzero(nz)
}

#[cfg(all(test, target_arch = "x86_64"))]
mod tests {
    use super::*;

    /// `get_fs` (lecture pure) réussit ; sous un binaire de test lié à la libc,
    /// `%fs` est déjà programmé (base TLS non nulle).
    #[test]
    fn get_fs_returns_nonzero_base() {
        let base = get_fs().expect("get_fs doit réussir");
        assert_ne!(base, 0, "la base TLS d'un thread libc est non nulle");
    }

    /// `set_fs` chemin **succès** sans rien casser : réécrire la **base
    /// courante** est un no-op effectif (le TLS de la libc reste valide) tout en
    /// exerçant le chemin nominal du syscall. Cf. ADR-051 (stratégie de test).
    #[test]
    fn set_fs_to_current_base_is_ok() {
        let base = get_fs().expect("get_fs");
        // SAFETY: on réécrit l'EXACTE base courante → l'image TLS reste celle,
        // valide, de la libc ; aucun état par-thread n'est invalidé.
        unsafe { set_fs(base) }.expect("set_fs(base courante) doit réussir");
        assert_eq!(get_fs().expect("get_fs"), base, "base inchangée");
    }

    /// `set_fs` chemin **erreur** : une adresse **non canonique** (bit 63 posé)
    /// est rejetée par le kernel **sans** modifier `%fs` → le TLS reste intact.
    #[test]
    fn set_fs_non_canonical_is_rejected_without_changing_fs() {
        let before = get_fs().expect("get_fs");
        let non_canonical: usize = 0x8000_0000_0000_0000;
        // SAFETY: adresse non canonique ⇒ le kernel valide et rejette AVANT de
        // toucher `%fs` ; aucun accès TLS n'est compromis.
        let err = unsafe { set_fs(non_canonical) };
        assert!(err.is_err(), "une base non canonique doit être rejetée");
        assert_eq!(
            get_fs().expect("get_fs"),
            before,
            "%fs inchangé après rejet"
        );
    }
}