From 880fcf0126912c2e3ae3b96ff1b90aef86653b25 Mon Sep 17 00:00:00 2001 From: amadeus Date: Wed, 18 Nov 2026 12:58:34 +0300 Subject: [PATCH] fix(storage): prevent unpublished ready-pack entries from causing false dependency cycles (#723) --- .../src/encoding/delta/read.rs | 7 +- .../crates/layerfs-storage/src/save/pooled.rs | 2 + .../crates/layerfs-storage/src/save/select.rs | 1 + .../crates/layerfs-storage/src/save/source.rs | 21 ++- core/crates/layerfs-storage/src/save/wave.rs | 3 + .../tests/concurrent_winner_chain.rs | 149 ++++++++++++++++++ 6 files changed, 177 insertions(+), 6 deletions(-) diff --git a/core/crates/layerfs-storage/src/encoding/delta/read.rs b/core/crates/layerfs-storage/src/encoding/delta/read.rs index 3d484c1772..1fc4c77a5c 100644 --- a/core/crates/layerfs-storage/src/encoding/delta/read.rs +++ b/core/crates/layerfs-storage/src/encoding/delta/read.rs @@ -243,7 +243,12 @@ impl<'a> Resolver<'a> { let mut chain: Vec = Vec::with_capacity(usize::from(role_depth) + 1); let mut current = root; loop { - if chain.iter().any(|row| row.object_id == current.object_id) { + if chain.iter().any(|row| { + row.object_id == current.object_id + && row.pack_id == current.pack_id + && row.group_number == current.group_number + && row.record_number == current.record_number + }) { return Err(StorageError::Integrity("dependency cycle")); } chain.push(current); diff --git a/core/crates/layerfs-storage/src/save/pooled.rs b/core/crates/layerfs-storage/src/save/pooled.rs index b19b4b09b5..8d6dc62a88 100644 --- a/core/crates/layerfs-storage/src/save/pooled.rs +++ b/core/crates/layerfs-storage/src/save/pooled.rs @@ -69,6 +69,7 @@ impl State<'_> { packer: &self.packer, signatures: &self.signatures, values: &self.values, + prefer_packer: false, }; for (ordinal, value) in ordinals.iter().zip(source.inode_values(&ordinals)?) { known.entry(value).or_insert(*ordinal); @@ -183,6 +184,7 @@ impl State<'_> { packer: &self.packer, signatures: &self.signatures, values: &self.values, + prefer_packer: false, }; let mut bases = Vec::new(); for id in advisory { diff --git a/core/crates/layerfs-storage/src/save/select.rs b/core/crates/layerfs-storage/src/save/select.rs index 83d94ddac9..2b69a7ba6c 100644 --- a/core/crates/layerfs-storage/src/save/select.rs +++ b/core/crates/layerfs-storage/src/save/select.rs @@ -75,6 +75,7 @@ impl State<'_> { packer: &self.packer, signatures: &self.signatures, values: &self.values, + prefer_packer: false, }; let capacities = self.storage.capacities(); let mut input = SelectInput { diff --git a/core/crates/layerfs-storage/src/save/source.rs b/core/crates/layerfs-storage/src/save/source.rs index 720333ef83..e9fa0513de 100644 --- a/core/crates/layerfs-storage/src/save/source.rs +++ b/core/crates/layerfs-storage/src/save/source.rs @@ -14,21 +14,32 @@ pub(super) struct WaveSource<'a> { pub(super) signatures: &'a RefCell>, /// Values this Save assigned and has not published yet, by ordinal. pub(super) values: &'a BTreeMap, + /// True only when reconstructing this Save's own lost candidate bytes. + pub(super) prefer_packer: bool, } impl Source for WaveSource<'_> { fn ordered_dependencies(&self) -> bool { false } fn location(&self, id: ObjectId, ceiling: i64) -> StorageResult> { - match self.packer.location(id) { - Some(row) => Ok(Some(row)), - None => self.fetch.location(id, ceiling), + if self.prefer_packer { + match self.packer.location(id) { + Some(row) => Ok(Some(row)), + None => self.fetch.location(id, ceiling), + } + } else { + match self.fetch.location(id, ceiling)? { + Some(row) => Ok(Some(row)), + None => Ok(self.packer.location(id)), + } } } fn base_location(&self, id: ObjectId, ceiling: i64) -> StorageResult> { - match self.packer.location(id) { + // A committed base in Fetch is the canonical first-wins winner; never + // let an unpublished tentative copy in `packer.ready` shadow it (#723). + match self.fetch.base_location(id, ceiling)? { Some(row) => Ok(Some(row)), - None => self.fetch.base_location(id, ceiling), + None => Ok(self.packer.location(id)), } } fn pack_bytes(&self, id: i64) -> StorageResult> { diff --git a/core/crates/layerfs-storage/src/save/wave.rs b/core/crates/layerfs-storage/src/save/wave.rs index 12917c55de..bd26c5377b 100644 --- a/core/crates/layerfs-storage/src/save/wave.rs +++ b/core/crates/layerfs-storage/src/save/wave.rs @@ -87,6 +87,7 @@ impl State<'_> { packer: &self.packer, signatures: &self.signatures, values: &self.values, + prefer_packer: false, }; if let Some(location) = view.location(object.id(), i64::MAX)? { // Exact reuse trusts the content address (owner, 2026-10-19; @@ -122,6 +123,7 @@ impl State<'_> { packer: &self.packer, signatures: &self.signatures, values: &self.values, + prefer_packer: false, }; self.candidates.flush(&view)?; Ok(()) @@ -135,6 +137,7 @@ impl State<'_> { packer: &self.packer, signatures: &self.signatures, values: &self.values, + prefer_packer: true, }; let capacities = self.storage.capacities(); let value = Resolver::new( diff --git a/core/crates/layerfs-storage/tests/concurrent_winner_chain.rs b/core/crates/layerfs-storage/tests/concurrent_winner_chain.rs index 83717da763..c5e78aa3a1 100644 --- a/core/crates/layerfs-storage/tests/concurrent_winner_chain.rs +++ b/core/crates/layerfs-storage/tests/concurrent_winner_chain.rs @@ -158,3 +158,152 @@ fn a_concurrent_winner_chain_resolves_a_base_this_wave_located_absent() { .collect(); assert_eq!(read, expected); } + +/// A tentative unpublished copy of `v1` (`v1 -> v0`) in `Packer::ready` must +/// never shadow the committed first-wins copy of `v1` in `Fetch` when walking +/// a committed base chain (`v0 -> v1`), or `DepthCache::cost_of` / `Resolver` +/// observes a false-positive `Integrity("dependency cycle")`. +#[test] +fn ready_pack_entry_never_shadows_a_committed_base_into_a_cycle() { + let base_bytes = support::noise(4096); + let p_bytes = support::noise(4096); + let p = whole(&p_bytes); + let x = hinted(whole(&edited(&p_bytes, 100, b"F723-x0!")), &p); + let v1 = whole(&base_bytes); + let v0_plain = whole(&edited(&base_bytes, 100, b"F723-v0!")); + let v0 = hinted(v0_plain.clone(), &v1); + let v1_hint_v0 = hinted(v1.clone(), &v0); + let v2 = hinted(whole(&edited(&base_bytes, 300, b"F723-v2!")), &v0); + // Incompressible payloads large enough to seal `v1_hint_v0` out of the + // open `WholeFile` group and flush `Packer::queued` into `Packer::ready` + // (> PACK_LIMIT = 256 KiB) before `v2` is offered. + let pad_noise = support::noise(6 * 60 * 1024); + let pads: Vec<_> = (0..6) + .map(|i| whole(&pad_noise[i * 60 * 1024..(i + 1) * 60 * 1024])) + .collect(); + + let shared = Arc::new(MemoryMetadata::default()); + let save_one = |metadata: Arc, object: FinalizedObject| { + let store = Storage::new(metadata).unwrap(); + let save = store.begin_save().unwrap(); + save.accept(object).unwrap(); + save.finish().unwrap() + }; + let (step_shared, v1_other, v0_other) = (shared.clone(), v1.clone(), v0.clone()); + let other_prefix = Arc::new(Mutex::new(0_u64)); + let recorded = other_prefix.clone(); + let steps: Vec> = vec![Box::new(move || { + save_one(step_shared.clone(), v1_other); + *recorded.lock().unwrap() = save_one(step_shared, v0_other).prefix_records; + })]; + let storage = Storage::new(Arc::new(Interleaved { + inner: shared.clone(), + before_publish: Mutex::new(steps), + })) + .unwrap(); + + // Wave: + // 1. `v0` (FULL) enters `Packer`. + // 2. `x` (hint `v0`) triggers `register_ready()`; `before_publish` commits + // `v1` (FULL) and `v0` (PREFIX -> `v1`). `v0` loses first-wins and is + // invalidated from `Fetch::absent`, while `v1` remains marked absent. + // 3. `v1_hint_v0` is not skipped (still in `absent`), sees `v0 -> v1` in + // `Fetch`, and encodes `v1 -> v0` into `Packer`. + // 4. `pad` seals `v1 -> v0` into `Packer::ready`. + // 5. `v2` (hint `v0`) does not flush `Packer::ready` because `v0` is already + // committed, and walks `v0 -> v1` via `WaveSource::base_location`. + let save = storage.begin_save().unwrap(); + for object in [&p, &v0_plain, &x, &v1_hint_v0] { + save.accept(object.clone()).unwrap(); + } + for pad in &pads { + save.accept(pad.clone()).unwrap(); + } + save.accept(v2.clone()).unwrap(); + save.finish() + .unwrap_or_else(|error| panic!("Save hit cycle or integrity error: {error:?}")); + assert_eq!( + *other_prefix.lock().unwrap(), + 1, + "fixture: concurrent writer must store v0 as PREFIX on v1" + ); + + let reader = Storage::new(shared).unwrap(); + let ids = [v0.id(), v1.id(), v2.id()]; + let read = reader.reader().unwrap().read_objects(&ids).unwrap(); + assert_eq!( + read, + vec![ + v0.canonical().to_vec(), + v1.canonical().to_vec(), + v2.canonical().to_vec(), + ] + ); +} + +/// When a Save loses first-wins on `v0` after encoding its private copy of +/// `v0` against `v1`, and the concurrent winner already stored `v1` as a +/// `PREFIX` on `v0`, `acknowledge()`'s `Wave::resolve(v0)` walks from the +/// unpublished `v0` through committed `v1` to committed `v0`. Different +/// `(pack_id, group, record)` locators must not be rejected as a cycle (#723). +#[test] +fn lost_candidate_resolving_through_winner_chain_to_same_object_id_is_not_a_cycle() { + let base_bytes = support::noise(4096); + let v0 = whole(&base_bytes); + let v1_plain = whole(&edited(&base_bytes, 100, b"F723-v1!")); + let v1_hint_v0 = hinted(v1_plain.clone(), &v0); + let v0_hint_v1 = hinted(v0.clone(), &v1_plain); + let p_bytes = support::noise(4096); + let p = whole(&p_bytes); + let x = hinted(whole(&edited(&p_bytes, 100, b"F723-x0!")), &p); + + let shared = Arc::new(MemoryMetadata::default()); + let save_one = |metadata: Arc, object: FinalizedObject| { + let store = Storage::new(metadata).unwrap(); + let save = store.begin_save().unwrap(); + save.accept(object).unwrap(); + save.finish().unwrap() + }; + let (step_shared, v0_other, v1_other) = (shared.clone(), v0.clone(), v1_hint_v0.clone()); + let other_prefix = Arc::new(Mutex::new(0_u64)); + let recorded = other_prefix.clone(); + let steps: Vec> = vec![Box::new(move || { + save_one(step_shared.clone(), v0_other); + *recorded.lock().unwrap() = save_one(step_shared, v1_other).prefix_records; + })]; + let storage = Storage::new(Arc::new(Interleaved { + inner: shared.clone(), + before_publish: Mutex::new(steps), + })) + .unwrap(); + + // 1. `p` enters `Packer`, `x` (hint `p`) triggers `register_ready()`. + // 2. `before_publish` commits `v0` (FULL) and `v1` (PREFIX -> `v0`). + // 3. `v1_plain` is published by `a` or `v1` is resolved via `x`? No, + // `v1_hint_v0`? Here `a` offers `v0_hint_v1`: `v0` is still in `absent` + // from the wave start, while `v1` is located via `register_ready`? No: + // `v1_plain` is also offered first so `register_ready` invalidates `v1`, + // then `v0_hint_v1` encodes `v0 -> v1` and loses `v0` at `finish()`. + let save = storage.begin_save().unwrap(); + for object in [&p, &x, &v1_plain, &v0_hint_v1] { + save.accept(object.clone()).unwrap(); + } + save.finish() + .unwrap_or_else(|error| panic!("Lost candidate resolution hit cycle: {error:?}")); + assert_eq!( + *other_prefix.lock().unwrap(), + 1, + "fixture: concurrent writer must store v1 as PREFIX on v0" + ); + + let reader = Storage::new(shared).unwrap(); + let read = reader + .reader() + .unwrap() + .read_objects(&[v0.id(), v1_plain.id()]) + .unwrap(); + assert_eq!( + read, + vec![v0.canonical().to_vec(), v1_plain.canonical().to_vec()] + ); +}