Hacktoberfest 2026: le issue che i maintainer hanno segnato per ottobre, aperte e adatte ai principianti. Sfoglia le issue Hacktoberfest

OnceMap and singleflight leak an entry when a duplicate key's destructor panics

Aperta
  • Qualcosa non va?
#388 0 commenti 0 reazioni 0 assegnatari Vedi su GitHub

I maintainer di solito rispondono entro 1 giorno

Nessuno ha ancora preso questa issue.

Valutazione

Difficoltà
4/5
Tempo stimato
1-2 giorni
Idoneità per principianti
55/100
Tipo di issue
Bug
Chiarezza
Specificata chiaramente
Stato di attività
Attiva
Stack tecnologico
rust
Ambito
backend

Direzione di ricerca

Start with asyncband/src/once/once_map/mod.rs around get_or_insert and the pending-entry cleanup guard, then inspect asyncband/src/singleflight/mod.rs around get_or_insert and WorkCleanupGuard::new. Reproduce the panic cases described in the issue and trace what happens on pending and cached paths. Done means both APIs clean up correctly after a duplicate key's destructor panics, including cancellation during the drop.

Scritto dal modello di indicizzazione a partire dal testo della issue.

Descrizione

Summary

While working on #387 I found another way OnceMap can keep an empty entry. When compute or try_compute joins a computation that is already running for the key, the caller's own key is no longer needed and is dropped. If that destructor panics and the panic is caught, for example by tokio::spawn, the caller's reference to the entry leaks. Once the original computation is cancelled or fails, the empty entry stays in the map for good. singleflight::Group::work and try_work have the same problem.

Reproducer

On main (8febdc7, Rust 1.96.0) this prints OnceMap { len: 1, pending: 1 }, and the same program with singleflight::Group::work prints Group { in_flight: 1 }. Both are empty when the destructor doesn't panic.

use std::future::pending;
use std::hash::{Hash, Hasher};
use std::panic::{AssertUnwindSafe, catch_unwind};
use std::pin::pin;
use std::task::{Context, Waker};

use asyncband::once::OnceMap;

struct Key(&'static str, bool);

impl PartialEq for Key {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
    }
}

impl Eq for Key {}

impl Hash for Key {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.0.hash(state);
    }
}

impl Drop for Key {
    fn drop(&mut self) {
        if self.1 {
            panic!("key destructor");
        }
    }
}

fn main() {
    let mut cx = Context::from_waker(Waker::noop());
    let map = OnceMap::<Key, i32>::new();

    let mut original = Box::pin(map.compute(Key("k", false), async || pending().await));
    assert!(original.as_mut().poll(&mut cx).is_pending());
    let joined = catch_unwind(AssertUnwindSafe(|| {
        let _ = pin!(map.compute(Key("k", true), async || pending().await)).poll(&mut cx);
    }));
    assert!(joined.is_err());

    drop(original);
    println!("{map:?}");
}

The leaked reference also keeps later values alive: if the key is computed again and then discarded, the value is never dropped. On a cached hit, the value clone that compute was about to return leaks instead.

Cause

The duplicate key is a parameter of get_or_insert (OnceMap, singleflight), so it is dropped when the function returns. If that destructor panics, Rust doesn't drop the value being returned (rust-lang/rust#47949, open since 2018), so the entry's Arc, or the cloned value on a cached hit, leaks. Even if it were dropped, no cleanup would run, because the guard is only created after get_or_insert returns. On OnceMap, making the drop explicit without moving the guard removes the permanent leak, but a cancellation that lands while the destructor runs still leaves an empty entry.

Possible fix

Drop the duplicate key explicitly, after creating the cleanup guard for a pending entry or cloning the value for a ready one. I tried this on OnceMap by having get_or_insert return either the value or the guard. Nothing leaks in the cases above, and the cached hit path still doesn't build a guard. singleflight would need the same change around WorkCleanupGuard::new.

Panicking destructors are unusual, so documenting the leak is also an option. I'd prefer to fix both, since the change is small. @tisonkun What do you think?

Lingua principale
Rust
Stelle
285
Fork
49
Merge medio
1g 1h
PR unite (30g)
33

Preparare l'ambiente

Questo progetto non fornisce container di sviluppo, Dockerfile né guida per i contributori, quindi l'ambiente è a tuo carico: parti dal suo README e consulta la nostra guida al primo contributo per i passaggi generali.

Come iniziare

  1. Leggi tutta la issue e poi la guida ai contributi del progetto.
  2. Commenta sulla issue per dire che te ne occupi tu — evita che due persone facciano lo stesso lavoro.
  3. Fai un fork del repository e lavora su un branch.
  4. Apri una pull request che faccia riferimento al numero della issue.

Altre issue di apache/asyncband

Tutte le issue di apache/asyncband

Issue simili

Altre issue su Rust

Ricevi le nuove issue nella tua casella

Un breve riepilogo di issue GitHub adatte ai principianti.