use super::ondisk::Compression;
use crate::compress::{self, Algorithm};
pub(crate) const MAX_UNCOMPRESSED: u64 = 128 << 10;
pub(crate) const MAX_COMPRESSED: u64 = 128 << 10;
const LZO_LEN: usize = 4;
pub(crate) const fn algorithm(compression: Compression) -> Option<Option<Algorithm>> {
match compression {
Compression::None => None,
Compression::Zlib => Some(Some(Algorithm::Zlib)),
Compression::Lzo => Some(Some(Algorithm::Lzo)),
Compression::Zstd => Some(Some(Algorithm::Zstd)),
Compression::Unknown(_) => Some(None),
}
}
pub(crate) fn decode(
algorithm: Algorithm,
input: &[u8],
out: &mut [u8],
sector_size: u32,
) -> Result<usize, compress::Error> {
match algorithm {
Algorithm::Lzo => lzo_segments(input, out, sector_size),
Algorithm::Zlib
| Algorithm::Zstd
| Algorithm::Lzvn
| Algorithm::Lzfse
| Algorithm::Lzbitmap => compress::decompress(algorithm, input, out),
}
}
fn lzo_segments(input: &[u8], out: &mut [u8], sector_size: u32) -> Result<usize, compress::Error> {
let malformed = |fault| compress::Error::Malformed {
algorithm: Algorithm::Lzo,
fault,
};
let sector = sector_size as usize;
let total =
length_at(input, 0).ok_or(malformed("the extent is shorter than its own length"))?;
if total > input.len() || total < LZO_LEN {
return Err(malformed("the extent's length is not the length it has"));
}
let mut read = LZO_LEN;
let mut written = 0;
while read < total {
let left_in_sector = sector - (read % sector);
if left_in_sector < LZO_LEN {
read += left_in_sector;
if read >= total {
break;
}
}
let segment =
length_at(input, read).ok_or(malformed("a segment header runs past the extent"))?;
read += LZO_LEN;
let stream = input
.get(read..read.saturating_add(segment))
.ok_or(malformed("a segment runs past the extent"))?;
let room = out
.len()
.checked_sub(written)
.filter(|left| *left > 0)
.ok_or(compress::Error::Overrun {
algorithm: Algorithm::Lzo,
expected: out.len(),
})?
.min(sector);
let produced =
compress::decompress(Algorithm::Lzo, stream, &mut out[written..written + room])?;
written += produced;
read += segment;
}
Ok(written)
}
fn length_at(input: &[u8], at: usize) -> Option<usize> {
let end = at.checked_add(LZO_LEN)?;
if end > input.len() {
return None;
}
Some(crate::bytes::get_u32(input, at) as usize)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_extent_bounds_are_the_ones_the_format_compresses_in() {
assert_eq!(MAX_UNCOMPRESSED, 131_072);
assert_eq!(MAX_COMPRESSED, 131_072);
}
#[test]
fn an_undefined_compression_byte_is_an_encoding_rather_than_no_encoding() {
assert!(algorithm(Compression::None).is_none());
assert_eq!(algorithm(Compression::Zlib), Some(Some(Algorithm::Zlib)));
assert_eq!(algorithm(Compression::Lzo), Some(Some(Algorithm::Lzo)));
assert_eq!(algorithm(Compression::Zstd), Some(Some(Algorithm::Zstd)));
assert_eq!(algorithm(Compression::Unknown(9)), Some(None));
}
#[cfg(feature = "lzo")]
mod framing {
use super::*;
fn frame(streams: &[Vec<u8>], sector: usize) -> Vec<u8> {
let mut out = vec![0u8; LZO_LEN];
for stream in streams {
if sector - (out.len() % sector) < LZO_LEN {
let pad = sector - (out.len() % sector);
out.resize(out.len() + pad, 0);
}
out.extend_from_slice(&(stream.len() as u32).to_le_bytes());
out.extend_from_slice(stream);
}
let total = out.len() as u32;
out[..LZO_LEN].copy_from_slice(&total.to_le_bytes());
out
}
fn compressed(data: &[u8]) -> Vec<u8> {
lzokay::compress::compress(data).expect("a second implementation compresses it")
}
#[test]
fn segments_concatenate_to_the_extent_the_writer_cut_up() {
let sector = 4096usize;
let parts: Vec<Vec<u8>> = (0..3)
.map(|which| {
(0..sector)
.map(|at| ((at / 64) + which * 7) as u8)
.collect()
})
.collect();
let framed = frame(
&parts.iter().map(|p| compressed(p)).collect::<Vec<_>>(),
sector,
);
let want: Vec<u8> = parts.concat();
let mut out = vec![0u8; want.len()];
assert_eq!(
decode(Algorithm::Lzo, &framed, &mut out, sector as u32),
Ok(want.len())
);
assert_eq!(out, want);
}
#[test]
fn a_segment_header_is_read_where_the_padding_puts_it() {
let sector = 512usize;
let mut streams = Vec::new();
let mut length = LZO_LEN;
while sector - (length % sector) > LZO_LEN + 2 {
let part = vec![0xa7u8; 64];
let stream = compressed(&part);
length += LZO_LEN + stream.len();
streams.push((part, stream));
}
let tail = vec![0x5eu8; 96];
streams.push((tail.clone(), compressed(&tail)));
let framed = frame(
&streams.iter().map(|(_, s)| s.clone()).collect::<Vec<_>>(),
sector,
);
assert!(
framed.len() > sector,
"the framing did not cross a sector: {} bytes",
framed.len()
);
let want: Vec<u8> = streams.iter().flat_map(|(p, _)| p.clone()).collect();
let mut out = vec![0u8; want.len()];
assert_eq!(
decode(Algorithm::Lzo, &framed, &mut out, sector as u32),
Ok(want.len())
);
assert_eq!(out, want);
}
const KERNEL_LZO_EXTENT: &[u8] = include_bytes!("fixtures/lzo-extent.bin");
#[test]
fn an_extent_a_kernel_compressed_expands_to_what_it_wrote() {
let unit = b"ferrosys-btrfs\n";
let mut want = Vec::with_capacity(128 << 10);
while want.len() < 128 << 10 {
want.extend_from_slice(unit);
}
want.truncate(128 << 10);
let mut out = vec![0u8; want.len()];
assert_eq!(
decode(Algorithm::Lzo, KERNEL_LZO_EXTENT, &mut out, 4096),
Ok(want.len())
);
assert_eq!(out, want);
}
#[test]
fn a_framing_that_claims_more_than_it_holds_is_refused() {
let sector = 4096usize;
let framed = frame(&[compressed(b"ferrosys")], sector);
let mut out = [0u8; 64];
let mut wrong = framed.clone();
wrong[..LZO_LEN].copy_from_slice(&(framed.len() as u32 + 1).to_le_bytes());
assert!(decode(Algorithm::Lzo, &wrong, &mut out, sector as u32).is_err());
let mut wrong = framed.clone();
wrong[LZO_LEN..LZO_LEN * 2].copy_from_slice(&u32::MAX.to_le_bytes());
assert!(decode(Algorithm::Lzo, &wrong, &mut out, sector as u32).is_err());
assert!(decode(Algorithm::Lzo, &[0, 0], &mut out, sector as u32).is_err());
}
#[test]
fn arbitrary_bytes_are_framing_that_refuses_or_fits() {
crate::compress::sweep_arbitrary_bytes(7, |bytes, out| {
decode(Algorithm::Lzo, bytes, out, 512)
});
}
}
}