Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 6 additions & 1 deletion core/crates/layerfs-storage/src/encoding/delta/read.rs
Original file line number Diff line number Diff line change
Expand Up @@ -243,7 +243,12 @@ impl<'a> Resolver<'a> {
let mut chain: Vec<ObjectLocation> = 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);
Expand Down
2 changes: 2 additions & 0 deletions core/crates/layerfs-storage/src/save/pooled.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down Expand Up @@ -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 {
Expand Down
1 change: 1 addition & 0 deletions core/crates/layerfs-storage/src/save/select.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand Down
21 changes: 16 additions & 5 deletions core/crates/layerfs-storage/src/save/source.rs
Original file line number Diff line number Diff line change
Expand Up @@ -14,21 +14,32 @@ pub(super) struct WaveSource<'a> {
pub(super) signatures: &'a RefCell<BTreeMap<usize, SignatureRow>>,
/// Values this Save assigned and has not published yet, by ordinal.
pub(super) values: &'a BTreeMap<u32, [u8; INODE_VALUE_BYTES]>,
/// 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<Option<ObjectLocation>> {
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<Option<ObjectLocation>> {
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<Vec<u8>> {
Expand Down
3 changes: 3 additions & 0 deletions core/crates/layerfs-storage/src/save/wave.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -122,6 +123,7 @@ impl State<'_> {
packer: &self.packer,
signatures: &self.signatures,
values: &self.values,
prefer_packer: false,
};
self.candidates.flush(&view)?;
Ok(())
Expand All @@ -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(
Expand Down
149 changes: 149 additions & 0 deletions core/crates/layerfs-storage/tests/concurrent_winner_chain.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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<MemoryMetadata>, 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<Box<dyn FnOnce() + Send>> = 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<MemoryMetadata>, 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<Box<dyn FnOnce() + Send>> = 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()]
);
}