use crate::bytes::{get_arr, get_u8, get_u32, get_u64, put_arr, put_u8, put_u32, put_u64};
use super::{CSUM_FIELD_LEN, DiskKey, ParseError};
pub const MAX_LEVEL: u8 = 7;
pub const LEAF_LEVEL: u8 = 0;
pub const HEADER_FLAG_WRITTEN: u64 = 1 << 0;
pub const HEADER_FLAG_RELOC: u64 = 1 << 1;
pub const BACKREF_REV_SHIFT: u32 = 56;
pub const BACKREF_REV_MIXED: u8 = 1;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct Header {
pub csum: [u8; CSUM_FIELD_LEN],
pub fsid: [u8; 16],
pub bytenr: u64,
pub flags: u64,
pub chunk_tree_uuid: [u8; 16],
pub generation: u64,
pub owner: u64,
pub nritems: u32,
pub level: u8,
}
impl Header {
pub const SIZE: usize = 101;
pub fn read_from(buf: &[u8]) -> Result<Self, ParseError> {
if buf.len() < Self::SIZE {
return Err(ParseError::TooShort {
structure: "btrfs_header",
need: Self::SIZE,
got: buf.len(),
});
}
Ok(Self {
csum: get_arr(buf, 0),
fsid: get_arr(buf, 32),
bytenr: get_u64(buf, 48),
flags: get_u64(buf, 56),
chunk_tree_uuid: get_arr(buf, 64),
generation: get_u64(buf, 80),
owner: get_u64(buf, 88),
nritems: get_u32(buf, 96),
level: get_u8(buf, 100),
})
}
pub fn write_to(&self, buf: &mut [u8]) {
assert!(
buf.len() >= Self::SIZE,
"a tree block header needs {} bytes and was given {}",
Self::SIZE,
buf.len()
);
put_arr(buf, 0, &self.csum);
put_arr(buf, 32, &self.fsid);
put_u64(buf, 48, self.bytenr);
put_u64(buf, 56, self.flags);
put_arr(buf, 64, &self.chunk_tree_uuid);
put_u64(buf, 80, self.generation);
put_u64(buf, 88, self.owner);
put_u32(buf, 96, self.nritems);
put_u8(buf, 100, self.level);
}
#[must_use]
pub const fn is_leaf(self) -> bool {
self.level == LEAF_LEVEL
}
#[must_use]
pub const fn backref_rev(self) -> u8 {
(self.flags >> BACKREF_REV_SHIFT) as u8
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct Item {
pub key: DiskKey,
pub offset: u32,
pub size: u32,
}
impl Item {
pub const SIZE: usize = 25;
pub fn read_from(buf: &[u8]) -> Result<Self, ParseError> {
if buf.len() < Self::SIZE {
return Err(ParseError::TooShort {
structure: "btrfs_item",
need: Self::SIZE,
got: buf.len(),
});
}
Ok(Self {
key: DiskKey::read_from(buf)?,
offset: get_u32(buf, 17),
size: get_u32(buf, 21),
})
}
pub fn write_to(&self, buf: &mut [u8]) {
assert!(
buf.len() >= Self::SIZE,
"a leaf item needs {} bytes and was given {}",
Self::SIZE,
buf.len()
);
self.key.write_to(buf);
put_u32(buf, 17, self.offset);
put_u32(buf, 21, self.size);
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct KeyPtr {
pub key: DiskKey,
pub blockptr: u64,
pub generation: u64,
}
impl KeyPtr {
pub const SIZE: usize = 33;
pub fn read_from(buf: &[u8]) -> Result<Self, ParseError> {
if buf.len() < Self::SIZE {
return Err(ParseError::TooShort {
structure: "btrfs_key_ptr",
need: Self::SIZE,
got: buf.len(),
});
}
Ok(Self {
key: DiskKey::read_from(buf)?,
blockptr: get_u64(buf, 17),
generation: get_u64(buf, 25),
})
}
pub fn write_to(&self, buf: &mut [u8]) {
assert!(
buf.len() >= Self::SIZE,
"a node key pointer needs {} bytes and was given {}",
Self::SIZE,
buf.len()
);
self.key.write_to(buf);
put_u64(buf, 17, self.blockptr);
put_u64(buf, 25, self.generation);
}
}
#[cfg(test)]
mod tests {
use super::super::ItemType;
use super::*;
fn a_header() -> Header {
Header {
csum: [0xa5; CSUM_FIELD_LEN],
fsid: [0x11; 16],
bytenr: 22_036_480,
flags: HEADER_FLAG_WRITTEN | (u64::from(BACKREF_REV_MIXED) << BACKREF_REV_SHIFT),
chunk_tree_uuid: [0x22; 16],
generation: 8,
owner: 3,
nritems: 4,
level: LEAF_LEVEL,
}
}
#[test]
fn a_header_round_trips_through_its_hundred_and_one_bytes() {
let header = a_header();
let mut buf = [0u8; Header::SIZE];
header.write_to(&mut buf);
assert_eq!(Header::read_from(&buf).expect("a full header"), header);
assert_eq!(&buf[48..56], &22_036_480u64.to_le_bytes());
assert_eq!(&buf[88..96], &3u64.to_le_bytes());
assert_eq!(&buf[96..100], &4u32.to_le_bytes());
assert_eq!(buf[100], 0);
}
#[test]
fn the_top_byte_of_the_flag_word_is_a_revision_and_not_eight_flags() {
let header = a_header();
assert_eq!(header.backref_rev(), BACKREF_REV_MIXED);
assert_eq!(header.flags & HEADER_FLAG_WRITTEN, HEADER_FLAG_WRITTEN);
assert_eq!(header.flags, 0x0100_0000_0000_0001);
assert!(header.is_leaf());
}
#[test]
fn a_buffer_shorter_than_a_header_holds_no_header() {
let err = Header::read_from(&[0u8; Header::SIZE - 1]).expect_err("a hundred bytes");
assert!(matches!(
err,
ParseError::TooShort {
need: 101,
got: 100,
..
}
));
}
#[test]
fn an_item_round_trips_and_its_offset_is_measured_from_the_end_of_the_header() {
let item = Item {
key: DiskKey::new(1, ItemType::DEV_ITEM, 1),
offset: 16_185,
size: 98,
};
let mut buf = [0u8; Item::SIZE];
item.write_to(&mut buf);
assert_eq!(Item::read_from(&buf).expect("a full item"), item);
assert_eq!(&buf[17..21], &16_185u32.to_le_bytes());
assert_eq!(&buf[21..25], &98u32.to_le_bytes());
assert_eq!(
Header::SIZE + item.offset as usize + item.size as usize,
16_384
);
}
#[test]
fn a_child_pointer_round_trips_through_its_thirty_three_bytes() {
let ptr = KeyPtr {
key: DiskKey::new(5, ItemType::ROOT_ITEM, 0),
blockptr: 30_441_472,
generation: 5,
};
let mut buf = [0u8; KeyPtr::SIZE];
ptr.write_to(&mut buf);
assert_eq!(KeyPtr::read_from(&buf).expect("a full pointer"), ptr);
assert_eq!(&buf[17..25], &30_441_472u64.to_le_bytes());
assert_eq!(&buf[25..33], &5u64.to_le_bytes());
}
#[test]
fn a_buffer_shorter_than_an_item_or_a_pointer_holds_neither() {
assert!(matches!(
Item::read_from(&[0u8; Item::SIZE - 1]),
Err(ParseError::TooShort {
need: 25,
got: 24,
..
})
));
assert!(matches!(
KeyPtr::read_from(&[0u8; KeyPtr::SIZE - 1]),
Err(ParseError::TooShort {
need: 33,
got: 32,
..
})
));
}
}