use std::collections::BTreeMap;
use std::collections::BTreeSet;
use serde::Deserialize;
use serde::Serialize;
use crate::types::DetPid;
use crate::types::OpenFileId;
#[derive(Clone)]
pub(super) struct LockLine {
pub(super) sequence: String,
pub(super) waiter: bool,
pub(super) fields: Vec<String>,
pub(super) owner_index: usize,
pub(super) object_index: usize,
}
pub(super) fn parse_line(line: &str) -> Option<LockLine> {
let fields = line
.split_whitespace()
.map(str::to_owned)
.collect::<Vec<_>>();
let waiter = fields.get(1).is_some_and(|field| field == "->");
let details = usize::from(waiter) + 1;
let owner_index = details + 3;
let object_index = details + 4;
let sequence = fields
.first()
.and_then(|field| field.strip_suffix(':'))
.filter(|field| !field.is_empty() && field.bytes().all(|byte| byte.is_ascii_digit()))?
.to_owned();
if fields.len() != details + 7
|| fields[owner_index].parse::<i64>().is_err()
|| fields[object_index].split(':').count() != 3
{
return None;
}
Some(LockLine {
sequence,
waiter,
fields,
owner_index,
object_index,
})
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
pub struct HeldLock {
pub class: String,
pub mode: String,
pub access: String,
pub object: String,
pub start: String,
pub end: String,
}
impl HeldLock {
fn from_line(row: &LockLine) -> Self {
let first = usize::from(row.waiter) + 1;
let field = |index: usize| row.fields[index].clone();
Self {
class: field(first),
mode: field(first + 1),
access: field(first + 2),
object: field(row.object_index),
start: field(row.object_index + 1),
end: field(row.object_index + 2),
}
}
fn on_null_device(&self) -> bool {
let mut parts = self.object.split(':');
let number = |part: Option<&str>| part.and_then(|part| u32::from_str_radix(part, 16).ok());
number(parts.next()) == Some(0) && number(parts.next()) == Some(0)
}
fn belongs_to_a_description(&self) -> bool {
self.class == "OFDLCK" || self.class == "FLOCK"
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct LockRowFacts {
pub sequence: String,
pub waiter: bool,
pub owner: i64,
pub lock: HeldLock,
}
pub(crate) fn lock_rows(contents: &[u8]) -> Option<Vec<LockRowFacts>> {
let text = std::str::from_utf8(contents).ok()?;
text.lines()
.map(|line| {
let row = parse_line(line)?;
Some(LockRowFacts {
owner: row.fields[row.owner_index].parse().ok()?,
lock: HeldLock::from_line(&row),
sequence: row.sequence,
waiter: row.waiter,
})
})
.collect()
}
pub(crate) fn held_locks_in_fdinfo(contents: &[u8]) -> Vec<HeldLock> {
let text = String::from_utf8_lossy(contents);
text.lines()
.filter_map(|line| line.strip_prefix("lock:"))
.filter_map(|row| parse_line(row.trim()))
.filter(|row| !row.waiter)
.map(|row| HeldLock::from_line(&row))
.filter(HeldLock::belongs_to_a_description)
.collect()
}
pub(crate) fn guest_lock_rows(
rows: &[LockRowFacts],
mut guest_process: impl FnMut(i64) -> bool,
held: &[HeldLock],
) -> Vec<bool> {
let mut unclaimed: BTreeMap<&HeldLock, usize> = BTreeMap::new();
for lock in held {
unclaimed.insert(lock, 1);
}
let owned = rows
.iter()
.map(|row| !row.waiter && row.owner > 0 && guest_process(row.owner))
.collect::<Vec<_>>();
for (row, owned) in rows.iter().zip(&owned) {
if *owned
&& row.lock.belongs_to_a_description()
&& let Some(count) = unclaimed.get_mut(&row.lock)
{
*count = count.saturating_sub(1);
}
}
let mut kept_groups = BTreeSet::new();
let mut keep = vec![false; rows.len()];
for (index, row) in rows.iter().enumerate() {
if row.waiter {
continue;
}
keep[index] = row.lock.on_null_device()
|| owned[index]
|| (row.lock.belongs_to_a_description()
&& unclaimed.get_mut(&row.lock).is_some_and(|count| {
let available = *count > 0;
*count = count.saturating_sub(1);
available
}));
if keep[index] {
kept_groups.insert(row.sequence.as_str());
}
}
for (index, row) in rows.iter().enumerate() {
if row.waiter {
keep[index] = kept_groups.contains(row.sequence.as_str())
&& (row.lock.on_null_device() || (row.owner > 0 && guest_process(row.owner)));
}
}
keep
}
type Table = u64;
#[derive(Debug, Default)]
pub(crate) struct LockLedger {
next_table: Table,
process_table: BTreeMap<DetPid, Table>,
owners: BTreeMap<Table, BTreeSet<DetPid>>,
references: BTreeMap<OpenFileId, BTreeMap<Table, u32>>,
locks: BTreeMap<OpenFileId, DescriptionLocks>,
after_exec: BTreeMap<DetPid, BTreeMap<OpenFileId, DescriptionLocks>>,
opaque: BTreeSet<DetPid>,
aliased_inodes: BTreeSet<String>,
aliased_everything: bool,
refused: Option<String>,
}
type DescriptionLocks = Result<Vec<HeldLock>, String>;
impl LockLedger {
fn table_of(&mut self, process: DetPid) -> Table {
if let Some(table) = self.process_table.get(&process) {
return *table;
}
let table = self.next_table;
self.next_table += 1;
self.process_table.insert(process, table);
self.owners.entry(table).or_default().insert(process);
table
}
fn set_references(&mut self, open_file: OpenFileId, table: Table, slots: u32) {
let references = self.references.entry(open_file).or_default();
if slots == 0 {
references.remove(&table);
} else {
references.insert(table, slots);
}
if references.is_empty() {
self.references.remove(&open_file);
self.locks.remove(&open_file);
}
}
pub(crate) fn note_locks(
&mut self,
process: DetPid,
open_file: OpenFileId,
locks: Vec<HeldLock>,
slots: u32,
) {
self.note(process, open_file, Ok(locks), slots);
}
pub(crate) fn note_unknown(
&mut self,
process: DetPid,
open_file: OpenFileId,
reason: String,
slots: u32,
) {
self.note(process, open_file, Err(reason), slots);
}
fn note(
&mut self,
process: DetPid,
open_file: OpenFileId,
locks: DescriptionLocks,
slots: u32,
) {
let table = self.table_of(process);
self.set_references(open_file, table, slots);
if self.references.contains_key(&open_file) {
self.locks.insert(open_file, locks);
}
}
pub(crate) fn release(&mut self, process: DetPid, open_file: OpenFileId, remaining: u32) {
if let Some(table) = self.process_table.get(&process).copied() {
self.set_references(open_file, table, remaining);
}
}
pub(crate) fn fork(&mut self, parent: DetPid, child: DetPid, shares_table: bool) {
self.forget_process(child);
self.after_exec.remove(&child);
self.opaque.remove(&child);
if shares_table {
self.opaque.insert(parent);
}
if shares_table || self.opaque.contains(&parent) {
self.opaque.insert(child);
}
let Some(table) = self.process_table.get(&parent).copied() else {
return;
};
if shares_table {
self.owners.entry(table).or_default().insert(child);
self.process_table.insert(child, table);
return;
}
let copy = self.table_of(child);
for references in self.references.values_mut() {
if let Some(slots) = references.get(&table).copied() {
references.insert(copy, slots);
}
}
}
pub(crate) fn exec(&mut self, process: DetPid) {
let mut kept = BTreeMap::new();
if let Some(table) = self.process_table.get(&process).copied() {
for (open_file, references) in &self.references {
if references.contains_key(&table)
&& let Some(locks) = self.locks.get(open_file)
{
kept.insert(*open_file, locks.clone());
}
}
}
self.forget_process(process);
self.after_exec.insert(process, kept);
}
pub(crate) fn exec_kept(&mut self, process: DetPid, surviving: &[(OpenFileId, u32)]) {
let kept = self.after_exec.remove(&process).unwrap_or_default();
for (open_file, slots) in surviving {
let Some(locks) = self
.locks
.get(open_file)
.or_else(|| kept.get(open_file))
.cloned()
else {
continue;
};
let table = self.table_of(process);
self.set_references(*open_file, table, *slots);
if self.references.contains_key(open_file) {
self.locks.insert(*open_file, locks);
}
}
}
pub(crate) fn prune(&mut self, mut alive: impl FnMut(DetPid) -> bool) {
self.opaque.retain(|process| alive(*process));
let gone = self
.owners
.iter()
.filter(|(_, owners)| owners.iter().any(|process| !alive(*process)))
.map(|(table, _)| *table)
.collect::<Vec<_>>();
for table in gone {
self.drop_table(table);
}
let processes = self.after_exec.keys().copied().collect::<Vec<_>>();
for process in processes {
if !alive(process) {
self.after_exec.remove(&process);
}
}
}
fn forget_process(&mut self, process: DetPid) {
let Some(table) = self.process_table.remove(&process) else {
return;
};
let empty = self.owners.get_mut(&table).is_none_or(|owners| {
owners.remove(&process);
owners.is_empty()
});
if empty {
self.drop_table(table);
}
}
fn drop_table(&mut self, table: Table) {
if let Some(owners) = self.owners.remove(&table) {
for process in owners {
if self.process_table.get(&process) == Some(&table) {
self.process_table.remove(&process);
}
}
}
let open_files = self.references.keys().copied().collect::<Vec<_>>();
for open_file in open_files {
self.set_references(open_file, table, 0);
}
}
pub(crate) fn mark_opaque(&mut self, process: DetPid) {
self.opaque.insert(process);
}
pub(crate) fn alias_inode(&mut self, inode: Option<String>) {
match inode {
Some(inode) => {
self.aliased_inodes.insert(inode);
}
None => self.aliased_everything = true,
}
}
pub(crate) fn held(&self) -> Vec<HeldLock> {
if self.aliased_everything {
return Vec::new();
}
let opaque_tables = self
.owners
.iter()
.filter(|(_, owners)| owners.iter().any(|process| self.opaque.contains(process)))
.map(|(table, _)| *table)
.collect::<BTreeSet<_>>();
self.locks
.iter()
.filter(|(open_file, _)| {
self.references.get(*open_file).is_some_and(|references| {
references
.keys()
.all(|table| !opaque_tables.contains(table))
})
})
.filter_map(|(_, locks)| locks.as_ref().ok())
.flat_map(|locks| locks.iter().cloned())
.filter(|lock| {
let inode = lock.object.rsplit(':').next().unwrap_or_default();
!self.aliased_inodes.contains(inode)
})
.collect()
}
pub(crate) fn refuse(&mut self, reason: String) {
self.refused.get_or_insert(reason);
}
pub(crate) fn unknown(&self) -> Option<&str> {
if let Some(reason) = &self.refused {
return Some(reason);
}
self.locks
.iter()
.filter(|(open_file, _)| self.references.contains_key(open_file))
.find_map(|(_, locks)| locks.as_ref().err())
.map(String::as_str)
}
}
const SEQ_FILE_MIN_BUFFER_BYTES: usize = 4096;
pub(crate) fn locks_capture_kept_bytes(reads: &[usize], chunk: usize) -> usize {
let mut later: usize = reads.iter().sum();
let mut kept = 0;
for &read in reads {
kept += read;
later -= read;
if read > 0 && read < chunk && read + later < SEQ_FILE_MIN_BUFFER_BYTES {
return kept;
}
}
kept
}
pub(crate) fn keep_lock_rows(contents: &[u8], kept: Option<&[bool]>) -> Vec<u8> {
let Some(kept) = kept else {
return contents.to_vec();
};
let Ok(text) = std::str::from_utf8(contents) else {
return Vec::new();
};
let lines = text.lines().collect::<Vec<_>>();
if lines.len() != kept.len() {
return Vec::new();
}
let mut out = Vec::new();
for (line, keep) in lines.into_iter().zip(kept) {
if *keep {
out.extend_from_slice(line.as_bytes());
out.push(b'\n');
}
}
if !text.ends_with('\n') && !out.is_empty() {
out.pop();
}
out
}
#[cfg(test)]
mod tests {
use super::*;
const SNAPSHOT: &[u8] = b"\
1: POSIX ADVISORY WRITE 3 00:2a:1001 0 EOF
2: OFDLCK ADVISORY WRITE -1 00:2a:1002 0 0
3: OFDLCK ADVISORY WRITE -1 00:18:588084 1073741824 1073741824
4: OFDLCK ADVISORY WRITE -1 00:2a:1002 10 10
5: FLOCK ADVISORY WRITE 4242 00:2a:1001 0 EOF
6: POSIX ADVISORY WRITE 4243 00:2a:1004 0 EOF
6: -> POSIX ADVISORY WRITE 3 00:2a:1004 0 EOF
7: OFDLCK ADVISORY WRITE -1 00:2a:1003 0 EOF
7: -> OFDLCK ADVISORY WRITE -1 00:2a:1003 0 EOF
7: -> POSIX ADVISORY WRITE 3 00:2a:1003 0 EOF
7: -> POSIX ADVISORY WRITE 0 00:2a:1003 0 EOF
";
const FDINFO: &[u8] = b"pos:\t0\nflags:\t02100002\nmnt_id:\t31\nino:\t1002\n\
lock:\t1: OFDLCK ADVISORY WRITE -1 00:2a:1002 0 0\n\
lock:\t2: POSIX ADVISORY WRITE 3 00:2a:1002 5 5\n\
lock:\t3: FLOCK ADVISORY WRITE 4242 00:2a:1001 0 EOF\n\
lock:\t4: OFDLCK ADVISORY WRITE -1 00:2a:1003 0 EOF\n";
fn guest(owner: i64) -> bool {
owner == 3
}
#[test]
fn parses_every_row_and_refuses_a_malformed_one() {
let rows = lock_rows(SNAPSHOT).unwrap();
assert_eq!(rows.len(), 11);
assert_eq!(rows[2].owner, -1);
assert_eq!(rows[2].lock.object, "00:18:588084");
assert_eq!(rows[2].lock.start, "1073741824");
assert!(rows[6].waiter && rows[6].sequence == "6" && rows[6].lock.class == "POSIX");
assert_eq!(rows[10].owner, 0);
assert!(lock_rows(b"1: POSIX ADVISORY WRITE 3 00:2a:1001 0 EOF\nnot a row\n").is_none());
assert!(lock_rows(b"").unwrap().is_empty());
}
#[test]
fn fdinfo_names_the_descriptions_ofd_and_flock_locks() {
let held = held_locks_in_fdinfo(FDINFO);
assert_eq!(
held.iter()
.map(|lock| (
lock.class.as_str(),
lock.object.as_str(),
lock.start.as_str()
))
.collect::<Vec<_>>(),
[
("OFDLCK", "00:2a:1002", "0"),
("FLOCK", "00:2a:1001", "0"),
("OFDLCK", "00:2a:1003", "0"),
]
);
assert!(held_locks_in_fdinfo(b"pos:\t0\nflags:\t02\n").is_empty());
assert!(held_locks_in_fdinfo(b"lock:\tnot a lock\n").is_empty());
}
#[test]
fn host_rows_are_dropped_and_the_guests_are_kept() {
let rows = lock_rows(SNAPSHOT).unwrap();
let held = held_locks_in_fdinfo(FDINFO);
assert_eq!(
guest_lock_rows(&rows, guest, &held),
[
true, true, false, false, true, false, false, true, false, true, false, ]
);
}
#[test]
fn with_no_description_locks_only_guest_processes_rows_stay() {
let rows = lock_rows(SNAPSHOT).unwrap();
assert_eq!(
guest_lock_rows(&rows, guest, &[]),
[
true, false, false, false, false, false, false, false, false, false, false
]
);
assert!(
guest_lock_rows(&rows, |_| false, &[])
.iter()
.all(|keep| !keep)
);
}
#[test]
fn a_distinct_lock_admits_one_row() {
let contents = b"\
1: OFDLCK ADVISORY READ -1 00:18:7 0 EOF
2: OFDLCK ADVISORY READ -1 00:18:7 0 EOF
";
let rows = lock_rows(contents).unwrap();
let held = held_locks_in_fdinfo(b"lock:\t1: OFDLCK ADVISORY READ -1 00:18:7 0 EOF\n");
assert_eq!(guest_lock_rows(&rows, guest, &held), [true, false]);
let twice = [held.clone(), held].concat();
assert_eq!(guest_lock_rows(&rows, guest, &twice), [true, false]);
}
#[test]
fn a_lock_on_another_device_with_the_same_inode_is_not_the_guests() {
let contents = b"\
1: OFDLCK ADVISORY WRITE -1 00:18:7 0 EOF
2: OFDLCK ADVISORY WRITE -1 00:2a:7 0 EOF
";
let rows = lock_rows(contents).unwrap();
let held = held_locks_in_fdinfo(b"lock:\t1: OFDLCK ADVISORY WRITE -1 00:18:7 0 EOF\n");
assert_eq!(guest_lock_rows(&rows, guest, &held), [true, false]);
assert_eq!(guest_lock_rows(&rows, guest, &[]), [false, false]);
}
#[test]
fn rows_a_backend_rendered_on_the_null_device_are_kept() {
let contents = b"\
1: OFDLCK ADVISORY WRITE -1 00:00:1 0 EOF
2: FLOCK ADVISORY WRITE 98765 00:00:2 0 EOF
";
let rows = lock_rows(contents).unwrap();
assert_eq!(guest_lock_rows(&rows, |_| false, &[]), [true, true]);
}
#[test]
fn dropped_rows_shift_no_remaining_identity() {
let rows = lock_rows(SNAPSHOT).unwrap();
let kept = guest_lock_rows(&rows, guest, &[]);
let mut file =
super::super::ProcfsFile::from_path(std::path::Path::new("/proc/locks")).unwrap();
file.initialize(
SNAPSHOT.to_vec(),
super::super::ProcfsSnapshotContext {
lock_rows_kept: Some(kept),
..Default::default()
},
);
let rendered = file.take(usize::MAX).unwrap();
assert_eq!(
rendered,
super::super::sanitize_locks(b"1: POSIX ADVISORY WRITE 3 00:2a:1001 0 EOF\n")
);
assert_eq!(
String::from_utf8(rendered).unwrap(),
"1: POSIX ADVISORY WRITE 1 00:00:1 0 EOF\n"
);
}
#[test]
fn a_guest_processs_row_claims_its_match_before_another_owners() {
let held = held_locks_in_fdinfo(b"lock:\t1: FLOCK ADVISORY READ 3 00:2a:5 0 EOF\n");
for (contents, want) in [
(
&b"1: FLOCK ADVISORY READ 3 00:2a:5 0 EOF\n2: FLOCK ADVISORY READ 4242 00:2a:5 0 EOF\n"[..],
[true, false],
),
(
&b"1: FLOCK ADVISORY READ 4242 00:2a:5 0 EOF\n2: FLOCK ADVISORY READ 3 00:2a:5 0 EOF\n"[..],
[false, true],
),
] {
let rows = lock_rows(contents).unwrap();
assert_eq!(guest_lock_rows(&rows, guest, &held), want);
}
}
fn lock(start: &str) -> HeldLock {
held_locks_in_fdinfo(
format!("lock:\t1: OFDLCK ADVISORY READ -1 00:18:7 {start} {start}\n").as_bytes(),
)
.remove(0)
}
fn description(sequence: u64) -> OpenFileId {
OpenFileId::new(DetPid::from_raw(3), sequence)
}
#[test]
fn a_description_counts_while_a_table_references_it() {
let [parent, child] = [3, 4].map(DetPid::from_raw);
let mut ledger = LockLedger::default();
ledger.note_locks(parent, description(0), vec![lock("0")], 1);
assert_eq!(ledger.held(), [lock("0")]);
ledger.note_locks(parent, description(0), Vec::new(), 1);
assert!(ledger.held().is_empty());
ledger.note_locks(parent, description(0), vec![lock("0")], 2);
ledger.release(parent, description(0), 1);
assert_eq!(ledger.held(), [lock("0")]);
ledger.fork(parent, child, false);
ledger.release(parent, description(0), 0);
assert_eq!(ledger.held(), [lock("0")]);
ledger.prune(|process| process != child);
assert!(ledger.held().is_empty());
ledger.release(DetPid::from_raw(9), description(0), 1);
assert!(ledger.held().is_empty());
}
#[test]
fn a_shared_table_closes_for_every_process_that_shares_it() {
let [parent, sibling] = [3, 4].map(DetPid::from_raw);
let mut ledger = LockLedger::default();
ledger.note_locks(parent, description(0), vec![lock("0")], 1);
ledger.fork(parent, sibling, true);
ledger.release(sibling, description(0), 0);
assert!(ledger.held().is_empty());
ledger.note_locks(parent, description(1), vec![lock("1")], 1);
ledger.prune(|process| process != sibling);
assert!(ledger.held().is_empty());
}
#[test]
fn an_exec_keeps_only_the_descriptions_that_survive_it() {
let process = DetPid::from_raw(3);
let mut ledger = LockLedger::default();
ledger.note_locks(process, description(0), vec![lock("0")], 1);
ledger.note_locks(process, description(1), vec![lock("1")], 1);
ledger.exec(process);
assert!(ledger.held().is_empty());
ledger.exec_kept(process, &[(description(0), 1)]);
assert_eq!(ledger.held(), [lock("0")]);
ledger.exec(process);
ledger.exec_kept(process, &[]);
assert!(ledger.held().is_empty());
}
#[test]
fn a_reused_process_number_starts_with_nothing() {
let [parent, child] = [3, 4].map(DetPid::from_raw);
let mut ledger = LockLedger::default();
ledger.note_locks(child, description(0), vec![lock("0")], 1);
ledger.fork(parent, child, false);
assert!(ledger.held().is_empty());
}
#[test]
fn a_reference_taken_before_any_lock_is_not_followed() {
let [parent, child] = [3, 4].map(DetPid::from_raw);
let mut ledger = LockLedger::default();
ledger.fork(parent, child, false);
ledger.note_locks(child, description(0), vec![lock("0")], 1);
assert_eq!(ledger.held(), [lock("0")]);
ledger.prune(|process| process != child);
assert!(ledger.held().is_empty());
}
#[test]
fn a_table_the_ledger_cannot_follow_contributes_no_lock() {
let [parent, sibling, child, other] = [3, 4, 5, 6].map(DetPid::from_raw);
let mut ledger = LockLedger::default();
ledger.fork(parent, sibling, true);
ledger.note_locks(parent, description(0), vec![lock("0")], 1);
assert!(ledger.held().is_empty());
ledger.fork(parent, child, false);
ledger.note_locks(child, description(1), vec![lock("1")], 1);
assert!(ledger.held().is_empty());
ledger.note_locks(other, description(2), vec![lock("2")], 1);
assert_eq!(ledger.held(), [lock("2")]);
ledger.mark_opaque(other);
assert!(ledger.held().is_empty());
ledger.prune(|process| process != other);
ledger.fork(DetPid::from_raw(9), other, false);
ledger.note_locks(other, description(3), vec![lock("3")], 1);
assert_eq!(ledger.held(), [lock("3")]);
}
#[test]
fn an_aliased_inode_contributes_no_lock() {
let process = DetPid::from_raw(3);
let mut ledger = LockLedger::default();
ledger.note_locks(process, description(0), vec![lock("0")], 1);
ledger.alias_inode(Some("8".to_string()));
assert_eq!(ledger.held(), [lock("0")]);
ledger.alias_inode(Some("7".to_string()));
assert!(ledger.held().is_empty());
let mut ledger = LockLedger::default();
ledger.note_locks(process, description(0), vec![lock("0")], 1);
ledger.alias_inode(None);
assert!(ledger.held().is_empty());
}
#[test]
fn a_refusal_holds_for_the_rest_of_the_run_by_its_first_reason() {
let process = DetPid::from_raw(3);
let mut ledger = LockLedger::default();
ledger.note_locks(process, description(0), vec![lock("0")], 1);
assert_eq!(ledger.unknown(), None);
ledger.refuse("ENFILE".to_string());
ledger.refuse("EIO".to_string());
assert_eq!(ledger.unknown(), Some("ENFILE"));
ledger.note_locks(process, description(0), Vec::new(), 1);
ledger.prune(|_| false);
assert_eq!(ledger.unknown(), Some("ENFILE"));
ledger.note_locks(process, description(1), vec![lock("1")], 1);
assert_eq!(ledger.held(), [lock("1")]);
}
#[test]
fn unknown_locks_count_while_a_table_references_them() {
let [parent, child] = [3, 4].map(DetPid::from_raw);
let mut ledger = LockLedger::default();
ledger.note_unknown(parent, description(0), "EMFILE".to_string(), 1);
assert_eq!(ledger.unknown(), Some("EMFILE"));
assert!(ledger.held().is_empty());
ledger.fork(parent, child, false);
ledger.release(parent, description(0), 0);
assert_eq!(ledger.unknown(), Some("EMFILE"));
ledger.prune(|process| process != child);
assert_eq!(ledger.unknown(), None);
ledger.note_unknown(parent, description(1), "EIO".to_string(), 1);
ledger.note_locks(parent, description(1), vec![lock("0")], 1);
assert_eq!(ledger.unknown(), None);
assert_eq!(ledger.held(), [lock("0")]);
ledger.note_unknown(parent, description(1), "ENFILE".to_string(), 1);
ledger.exec(parent);
assert_eq!(ledger.unknown(), None);
ledger.exec_kept(parent, &[(description(1), 1)]);
assert_eq!(ledger.unknown(), Some("ENFILE"));
}
#[test]
fn kept_rows_preserve_order_and_the_final_newline() {
let contents = b"1: A\n2: B\n3: C\n";
assert_eq!(
keep_lock_rows(contents, Some(&[true, false, true][..])),
b"1: A\n3: C\n"
);
assert_eq!(
keep_lock_rows(b"1: A\n2: B", Some(&[false, true][..])),
b"2: B"
);
assert_eq!(keep_lock_rows(contents, Some(&[false; 3][..])), b"");
assert_eq!(keep_lock_rows(contents, None), contents);
assert_eq!(keep_lock_rows(contents, Some(&[true][..])), b"");
}
#[test]
fn a_short_read_that_reached_the_end_drops_what_the_closing_reads_repeat() {
const CHUNK: usize = 64 * 1024;
assert_eq!(locks_capture_kept_bytes(&[82, 40], CHUNK), 82);
assert_eq!(locks_capture_kept_bytes(&[82, 40, 40, 40], CHUNK), 82);
assert_eq!(locks_capture_kept_bytes(&[82], CHUNK), 82);
assert_eq!(locks_capture_kept_bytes(&[], CHUNK), 0);
assert_eq!(locks_capture_kept_bytes(&[512, 40], 512), 552);
assert_eq!(locks_capture_kept_bytes(&[3000, 1096], CHUNK), 4096);
assert_eq!(locks_capture_kept_bytes(&[3000, 1095], CHUNK), 3000);
assert_eq!(
locks_capture_kept_bytes(&[4040, 4065, 3737, 74], CHUNK),
4040 + 4065 + 3737
);
assert_eq!(
locks_capture_kept_bytes(&[4040, 4065, 3737], CHUNK),
4040 + 4065 + 3737
);
assert_eq!(locks_capture_kept_bytes(&[512, 300, 40], 512), 812);
}
}