FerrousPath

Nivel 3 · Sistemas· Lección 7 de 11 · 35 min

Rust unsafe

Qué desbloquea realmente unsafe, qué es el comportamiento indefinido, los punteros crudos, y cómo envolver lo inseguro en una API segura y correcta.

Por qué existe unsafe

El subconjunto seguro de Rust es deliberadamente conservador: rechaza todo programa cuya seguridad de memoria no puede demostrar, incluidos muchos que están bien. Hay cosas que el compilador no podrá demostrar nunca: hablar con el hardware, llamar a C, implementar el propio Vec. unsafe es donde le dices al compilador: esto lo he comprobado yo.

El contrato de Rust es que esa obligación se mantiene local. El código unsafe se envuelve en abstracciones seguras, y quienes usan esas abstracciones nunca pueden causar errores de memoria. Cuando algo sale mal, auditas los bloques unsafe y el módulo que los rodea, no el programa entero.

Los cinco superpoderes

Dentro de unsafe { } puedes, además:

  1. Desreferenciar un puntero crudo (*const T, *mut T).
  2. Llamar a una función o un método unsafe.
  3. Leer o escribir una static mut.
  4. Implementar un trait unsafe (como Send o Sync).
  5. Acceder a los campos de una union.

Eso es todo. El borrow checker, el comprobador de tipos y el de lifetimes siguen funcionando sobre todo lo demás.

Punteros crudos

fn main() {
    let mut value = 10;

    // Crear punteros crudos es seguro. Solo desreferenciarlos no lo es.
    let r: *const i32 = &value;
    let w: *mut i32 = &raw mut value;

    unsafe {
        *w += 1;
        println!("{} {}", *r, *w);
    }

    let nowhere = 0x1234usize as *const i32; // crear esto no tiene problema…
    println!("{nowhere:?}");                 // …imprimir la dirección tampoco…
    // unsafe { println!("{}", *nowhere); }  // …desreferenciarlo es comportamiento indefinido.
}

Los punteros crudos pueden ser nulos, colgantes, estar mal alineados o tener aliasing. No tienen lifetime ni limpieza automática. &raw const x y &raw mut x crean uno sin pasar por una referencia, algo necesario para los campos de structs empaquetados y para la memoria sin inicializar.

Comportamiento indefinido

El comportamiento indefinido (UB) no es «el programa se cae». Significa que el compilador tenía derecho a suponer que eso nunca ocurre, y optimizó en consecuencia; el resultado puede ser cualquier cosa, incluido parecer que funciona hasta que cambia algo que no tiene relación. Las fuentes principales:

  • Desreferenciar un puntero colgante, nulo o mal alineado; leer fuera de los límites.
  • Una carrera de datos.
  • Producir un valor inválido: un bool que no es 0 ni 1, un discriminante de enum inválido, un char fuera del rango de valores escalares Unicode, una referencia nula o colgante, un entero sin inicializar.
  • Violar las reglas de aliasing: modificar a través de un &T (sin UnsafeCell), o tener un &mut T que no es único.
  • Llamar a una función con la ABI o la firma equivocadas; deshacer la pila a través de una ABI que no lo permite.
  • Romper una precondición de una biblioteca documentada bajo # Safety.

Fíjate en lo que no es UB: el desbordamiento de enteros (pánico o vuelta), las fugas de memoria, los interbloqueos, los pánicos.

Construir una abstracción segura

El split_at_mut de la biblioteca estándar devuelve dos slices mutables de un mismo slice que no se solapan. El borrow checker no puede ver que las mitades son disjuntas, así que el código seguro no puede expresarlo:

fn split_at_mut<T>(slice: &mut [T], mid: usize) -> (&mut [T], &mut [T]) {
    let len = slice.len();
    let ptr = slice.as_mut_ptr();
    assert!(mid <= len, "mid out of bounds"); // la comprobación que hace correcta la API

    // SAFETY: `mid <= len`, así que los dos rangos están dentro del slice original.
    // [0, mid) y [mid, len) no se solapan, así que los dos &mut son únicos.
    unsafe {
        (
            std::slice::from_raw_parts_mut(ptr, mid),
            std::slice::from_raw_parts_mut(ptr.add(mid), len - mid),
        )
    }
}

fn main() {
    let mut data = [1, 2, 3, 4, 5, 6];
    let (left, right) = split_at_mut(&mut data, 2);
    left[0] = 100;
    right[0] = 300;
    println!("{data:?}");
}

La función es segura de llamar con cualquier argumento: un mid incorrecto provoca un pánico antes de que se ejecute ningún código unsafe. Ese es el estándar: una función segura tiene que ser imposible de usar mal hasta provocar UB. Borra el assert! y la función pasa a ser incorrecta (unsound): sigue compilando, sigue funcionando casi siempre, y está mal.

unsafe fn y comentarios de seguridad

  • Una unsafe fn tiene precondiciones que el compilador no puede comprobar. Documéntalas bajo # Safety.
  • Todo bloque unsafe { } debería llevar un comentario // SAFETY: que explique por qué se cumplen las precondiciones.
/// Devuelve el elemento en `index` sin comprobar los límites.
///
/// # Safety
/// `index` debe ser menor que `slice.len()`.
unsafe fn get_fast(slice: &[u32], index: usize) -> u32 {
    // SAFETY: quien llama garantiza que index < len.
    unsafe { *slice.get_unchecked(index) }
}

fn main() {
    let data = [10, 20, 30];
    // SAFETY: 1 < 3.
    let x = unsafe { get_fast(&data, 1) };
    println!("{x}");
}

Desde la edición 2024, el cuerpo de una unsafe fn ya no es un bloque unsafe implícito: cada operación unsafe de dentro necesita su propio unsafe { }.

Traits unsafe

Un trait es unsafe cuando implementarlo supone una promesa de la que depende otro código unsafe.

use std::cell::UnsafeCell;
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread;

/// Un spin lock mínimo, para mostrar de dónde viene `unsafe impl Sync`.
struct SpinLock<T> {
    locked: AtomicBool,
    value: UnsafeCell<T>,
}

// SAFETY: el acceso a `value` está serializado por `locked`, así que compartir &SpinLock<T>
// entre hilos solo da acceso al T a un hilo cada vez.
unsafe impl<T: Send> Sync for SpinLock<T> {}

impl<T> SpinLock<T> {
    fn new(value: T) -> Self {
        SpinLock { locked: AtomicBool::new(false), value: UnsafeCell::new(value) }
    }

    fn with<R>(&self, f: impl FnOnce(&mut T) -> R) -> R {
        while self.locked.compare_exchange_weak(false, true, Ordering::Acquire, Ordering::Relaxed).is_err() {
            std::hint::spin_loop();
        }
        // SAFETY: tenemos el cerrojo, así que no existe ningún otro &mut T.
        let result = f(unsafe { &mut *self.value.get() });
        self.locked.store(false, Ordering::Release);
        result
    }
}

fn main() {
    let lock = SpinLock::new(0u64);
    thread::scope(|s| {
        for _ in 0..4 {
            s.spawn(|| for _ in 0..10_000 { lock.with(|v| *v += 1) });
        }
    });
    println!("{}", lock.with(|v| *v));
}

UnsafeCell<T> es la única primitiva que hace legal la mutación a través de un &. Cell, RefCell, Mutex y los atómicos están todos construidos sobre ella. (Este cerrojo no es seguro ante pánicos: si f entra en pánico, el cerrojo queda tomado. Una implementación real usa una guarda con Drop.)

Miri

Miri es un intérprete de la representación intermedia de nivel medio de Rust que detecta la mayor parte del UB en tiempo de ejecución: accesos fuera de los límites, uso después de liberar, valores inválidos, violaciones de aliasing, lecturas sin inicializar y algunas carreras de datos.

rustup +nightly component add miri
cargo +nightly miri test

En la página del Playground, carga el ejemplo «Comportamiento indefinido» y pulsa Miri. Una ejecución normal imprime una respuesta plausible; Miri informa de la violación exacta. Ejecuta por rutina con Miri las pruebas de tu código unsafe. Solo comprueba los caminos que ejecutan tus pruebas, así que complementa la revisión en lugar de sustituirla.

Disciplina

  • Mantén pequeños los bloques unsafe y explícitos los invariantes del módulo que los rodea. La corrección depende a menudo de los campos privados: cualquier código seguro del módulo que pueda modificar el len de tu vector forma parte de la base de confianza.
  • Prefiere las abstracciones seguras existentes (split_at_mut, chunks_exact, bytemuck, zerocopy) a escribir las tuyas.
  • Demuestra las afirmaciones sobre rendimiento antes de recurrir a get_unchecked. El optimizador ya elimina la mayoría de las comprobaciones de límites.
  • Activa #![deny(unsafe_op_in_unsafe_fn)] en las ediciones antiguas y clippy::undocumented_unsafe_blocks.

El nivel 4 va mucho más a fondo: layout, varianza, drop check e implementar Vec a partir de memoria en bruto.

Ejercicios

  1. Implementa fn swap_elements<T>(slice: &mut [T], i: usize, j: usize) usando ptr::swap. ¿Qué tienes que comprobar, y qué ocurre cuando i == j?
  2. Escribe una función segura fn as_bytes(x: &u32) -> &[u8] con slice::from_raw_parts. ¿Por qué la dirección contraria, de &[u8] a &u32, no siempre es correcta?
  3. Lo siguiente es incorrecto (unsound). Encuentra una llamada desde código seguro que provoque UB y después arregla la API: pub fn first<T>(v: &Vec<T>) -> &T { unsafe { &*v.as_ptr() } }
  4. Añade una guarda RAII a SpinLock para que se desbloquee ante un pánico.
Respuestas del 2 y del 3

2. u8 tiene alineación 1 y ningún patrón de bits inválido, así que cualquier memoria puede verse como bytes. Un &u32 debe estar alineado a 4 bytes; un slice de bytes arbitrario puede no estarlo. (Además, su longitud puede ser menor que 4.)

3. first(&Vec::<i32>::new()) devuelve una referencia a un puntero colgante. Devuelve Option<&T> o comprueba que no está vacío antes del bloque unsafe.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Cuál de estas cosas permite un bloque unsafe?

  2. 2.¿Qué significa que una API segura construida sobre código unsafe sea *sound* (correcta)?

  3. 3.¿Es comportamiento indefinido crear un &mut T que tenga aliasing con un &T vivo a los mismos datos, aunque ninguno se use nunca para escribir?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?