FerrousPath

Nivel 4 · Experto· Lección 3 de 9 · 30 min

Drop, drop check y PhantomData

El orden de los destructores, la seguridad ante pánicos y ante fugas, por qué un Drop genérico hace más estricto al borrow checker, y cómo PhantomData expresa la propiedad.

Los destructores, con precisión

Cuando un valor sale de ámbito, Rust ejecuta su código de liberación (drop glue): primero el Drop::drop del propio tipo, si lo tiene, y después el código de liberación de cada campo en el orden de declaración.

struct Noisy(&'static str);
impl Drop for Noisy {
    fn drop(&mut self) { println!("  drop {}", self.0); }
}

struct Pair { first: Noisy, second: Noisy }
impl Drop for Pair {
    fn drop(&mut self) { println!("  drop Pair (fields are still valid here)"); }
}

fn main() {
    println!("locals: reverse declaration order");
    let _a = Noisy("a");
    let _b = Noisy("b");

    println!("fields: declaration order, after the struct's own drop");
    let _p = Pair { first: Noisy("first"), second: Noisy("second") };

    println!("temporaries: end of the enclosing statement");
    let _len = Noisy("temp").0.len();

    println!("`let _ = ` does not bind: dropped immediately");
    let _ = Noisy("unbound");

    println!("end of main");
}

Hechos que merece la pena memorizar:

  • Las variables locales se liberan en orden inverso; los campos, los elementos de una tupla y los de un array, en orden directo.
  • Drop::drop recibe &mut self, así que no puedes mover un campo hacia fuera. Usa Option::take, ManuallyDrop o mem::replace.
  • Un tipo no puede ser a la vez Copy y Drop.
  • Mover desde una variable cancela su liberación; cuando el movimiento es condicional, el compilador lo sigue con banderas de liberación (drop flags) ocultas.
  • let _ = expr; libera inmediatamente; let _guard = expr; mantiene el valor hasta el final del ámbito. Confundirlos con la guarda de un cerrojo es un bug clásico.

Seguridad ante pánicos

Un pánico deshace la pila, ejecutando los destructores por el camino. El código unsafe debe por tanto mantener intactos sus invariantes en cada punto donde pueda producirse un pánico, lo que incluye toda llamada a código proporcionado por el usuario: una clausura, Clone::clone, Ord::cmp, Drop::drop.

/// Aplica `f` a cada elemento en el sitio. Correcto incluso si `f` entra en pánico.
fn map_in_place<T>(v: &mut Vec<T>, mut f: impl FnMut(T) -> T) {
    struct Guard<'a, T> { v: &'a mut Vec<T>, done: usize, len: usize }

    impl<T> Drop for Guard<'_, T> {
        fn drop(&mut self) {
            // Si llegamos aquí deshaciendo la pila, el elemento `done` se movió fuera y nunca se repuso.
            // Libera los elementos que van después de él y expón solo los ya transformados.
            if self.done < self.len {
                // SAFETY: los elementos done+1..len siguen inicializados y se liberan exactamente una vez.
                unsafe {
                    let tail = self.v.as_mut_ptr().add(self.done + 1);
                    std::ptr::slice_from_raw_parts_mut(tail, self.len - self.done - 1).drop_in_place();
                }
            }
            // SAFETY: exactamente los `done` primeros elementos están inicializados.
            unsafe { self.v.set_len(self.done) };
        }
    }

    let len = v.len();
    // SAFETY: mientras se ejecuta el bucle, el Vec dice estar vacío, así que un pánico no puede liberar dos veces.
    unsafe { v.set_len(0) };
    let mut g = Guard { v, done: 0, len };
    while g.done < g.len {
        // SAFETY: el índice está dentro de los límites; el hueco se lee una vez y después se sobrescribe.
        unsafe {
            let slot = g.v.as_mut_ptr().add(g.done);
            let new = f(slot.read()); // puede entrar en pánico: la guarda limpia
            slot.write(new);
        }
        g.done += 1;
    }
}

fn main() {
    let mut names = vec![String::from("a"), String::from("b"), String::from("c")];
    map_in_place(&mut names, |s| s + "!");
    println!("{names:?}");

    let result = std::panic::catch_unwind(move || {
        map_in_place(&mut names, |s| if s == "b!" { panic!("boom") } else { s });
    });
    println!("survived a panic without double free: {}", result.is_err());
}

La disciplina: antes de llamar a código ajeno, deja la estructura de datos en un estado que sea seguro liberar, y usa una guarda cuyo destructor restaure o trunque. Las implementaciones de Vec::retain, drain y de la ordenación en la biblioteca estándar la siguen todas. Una función que deja la memoria segura después de un pánico es segura ante excepciones (exception safe); si los datos siguen teniendo sentido es una cuestión lógica, más débil (eso es lo que señala el envenenamiento de un mutex).

Provocar fugas es seguro

mem::forget, un ciclo de referencias con Rc o un hilo que no termina nunca impiden que se ejecute un destructor, y todo ello en código completamente seguro. Por tanto:

Ningún código unsafe puede depender de que se ejecute un destructor para garantizar la seguridad de memoria.

Esto se aprendió por las malas justo antes de Rust 1.0 (el «leakpocalypse»): la API original de hilos con ámbito devolvía una guarda que unía el hilo al liberarse, y olvidar la guarda permitía que un hilo sobreviviera a los datos que había tomado prestados. El thread::scope moderno recibe una clausura, así que la unión ocurre en código que el usuario no puede saltarse. Vec::drain muestra la otra defensa: pone a cero la longitud del vector por adelantado, de modo que si se pierde el Drain, el vector simplemente pierde elementos en lugar de exponer los que ya se movieron.

Drop check

Considera un struct que guarda una referencia y tiene un destructor. El destructor podría leer a través de esa referencia, así que el referente debe sobrevivir estrictamente al struct:

struct Inspector<'a>(&'a String);

impl Drop for Inspector<'_> {
    fn drop(&mut self) {
        println!("inspector sees: {}", self.0); // usa el préstamo durante la liberación
    }
}

fn main() {
    let inspector;
    let text = String::from("data");
    inspector = Inspector(&text); // ❌ error[E0597]: `text` no vive lo suficiente
} // las locales se liberan en orden inverso: primero `text` y después `inspector`, cuyo drop leería memoria liberada

Quita el impl de Drop y esto compila: sin destructor, nada puede observar la referencia colgante. Este análisis es el drop checker. Su regla: si un tipo tiene un impl de Drop genérico sobre un lifetime o un parámetro de tipo, el compilador supone de forma conservadora que el destructor puede acceder a datos de ese lifetime o de ese tipo, así que esos datos deben sobrevivir al valor.

Intercambia las dos líneas let para que text se declare primero, y compila: el orden de declaración fija el orden de liberación.

La salida de emergencia: #[may_dangle]

El destructor de Vec<T> libera sus T, pero por lo demás nunca los lee. Así que un Vec<&'a str> se puede liberar sin peligro después de que 'a haya terminado (liberar una referencia no hace nada). La biblioteca estándar se lo dice al drop checker con un atributo inestable e unsafe:

// De la biblioteca estándar (simplificado); `may_dangle` requiere nightly.
unsafe impl<#[may_dangle] T, A: Allocator> Drop for Vec<T, A> {
    fn drop(&mut self) { /* libera cada elemento, libera el búfer */ }
}

#[may_dangle] T promete: «mi destructor no accede a T salvo para liberarlo». Y esa excepción es la razón de que PhantomData importe.

PhantomData

Un tipo que gestiona memoria a través de un puntero crudo no tiene ningún campo de tipo T, así que el compilador no sabe nada de su relación con T. PhantomData<T> es un campo de tamaño cero que dice «trátame como si almacenara un T»:

use std::marker::PhantomData;
use std::ptr::NonNull;

struct MyBox<T> {
    ptr: NonNull<T>,          // covariante, no nulo, habilita el nicho de Option
    _owns: PhantomData<T>,    // somos dueños de un T: liberaremos uno
}

impl<T> MyBox<T> {
    fn new(value: T) -> Self {
        let ptr = NonNull::from(Box::leak(Box::new(value)));
        MyBox { ptr, _owns: PhantomData }
    }
}

impl<T> std::ops::Deref for MyBox<T> {
    type Target = T;
    fn deref(&self) -> &T {
        // SAFETY: ptr vino de un Box vivo y no lo hemos liberado.
        unsafe { self.ptr.as_ref() }
    }
}

impl<T> Drop for MyBox<T> {
    fn drop(&mut self) {
        // SAFETY: ptr vino de Box::leak y se libera exactamente una vez.
        unsafe { drop(Box::from_raw(self.ptr.as_ptr())) };
    }
}

// SAFETY: MyBox<T> es dueño único de su T, exactamente igual que Box<T>.
unsafe impl<T: Send> Send for MyBox<T> {}
unsafe impl<T: Sync> Sync for MyBox<T> {}

fn main() {
    let b = MyBox::new(String::from("owned through a raw pointer"));
    println!("{} ({} bytes)", *b, std::mem::size_of::<Option<MyBox<String>>>());
}

PhantomData<T> tiene tres efectos:

  1. Varianza: el struct es covariante en T (consulta la tabla de la lección anterior para ver las alternativas).
  2. Auto traits: Send/Sync se heredan de T. (Aquí NonNull ya los quita, así que los volvemos a añadir con unsafe impl explícitos y con restricciones.)
  3. Drop check: combinado con #[may_dangle], le dice al checker que liberar este tipo libera un T.

Desde Rust 1.0, el tercer punto solo importa junto con #[may_dangle]: un tipo con un impl de Drop normal ya se trata de forma conservadora. Pero escribir PhantomData<T> en todo tipo que sea dueño a través de un puntero crudo sigue siendo el hábito correcto y autodocumentado.

ManuallyDrop

ManuallyDrop<T> envuelve un valor cuyo destructor no se ejecutará automáticamente. Es la forma de mover un campo hacia fuera dentro de drop, de controlar explícitamente el orden de liberación o de entregar la propiedad a código con punteros crudos:

use std::mem::ManuallyDrop;

struct Session { log: ManuallyDrop<Vec<String>> }

impl Drop for Session {
    fn drop(&mut self) {
        // SAFETY: `log` no se vuelve a usar después de esto; la liberación propia del campo está suprimida.
        let log = unsafe { ManuallyDrop::take(&mut self.log) };
        println!("flushing {} entries by value: {log:?}", log.len());
    }
}

fn main() {
    let _s = Session { log: ManuallyDrop::new(vec!["start".into(), "stop".into()]) };
}

Ejercicios

  1. Predice la salida completa de un programa con structs anidados, una tupla, un temporal en la expresión examinada por un match y un let _ =. Después ejecútalo.
  2. Escribe una fn map_in_place ingenua, sin la guarda; encuentra la doble liberación con Miri pasándole una clausura que entre en pánico bajo catch_unwind, y después añade la guarda.
  3. Toma el ejemplo de Inspector y haz que compile de tres maneras: reordenando las declaraciones; quitando el impl de Drop; guardando un String con dueño.
  4. ¿Por qué sería incorrecto esto si no se pudiera suponer que las fugas son seguras? Un struct JoinGuard<'a>(…) cuyo Drop une un hilo que toma prestados datos de 'a. Escribe el exploit en pseudocódigo con mem::forget.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿En qué orden se liberan los campos de un struct?

  2. 2.¿Por qué std::thread::scoped (antes de la 1.0) resultó ser incorrecto (unsound)?

  3. 3.¿Qué le dice al compilador añadir PhantomData<T> a un struct que contiene un *mut T?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?