use crate::Timestamp;
use crate::bytes::{get_u16, get_u32, get_u64, put_u16, put_u32, put_u64};
use crate::flags::flag_set;
use super::{Packed, ParseError, read_timespec, write_timespec};
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct InodeFlags(u64);
flag_set!(InodeFlags: u64);
impl InodeFlags {
pub const NODATASUM: Self = Self(1 << 0);
pub const NODATACOW: Self = Self(1 << 1);
pub const READONLY: Self = Self(1 << 2);
pub const NOCOMPRESS: Self = Self(1 << 3);
pub const PREALLOC: Self = Self(1 << 4);
pub const SYNC: Self = Self(1 << 5);
pub const IMMUTABLE: Self = Self(1 << 6);
pub const APPEND: Self = Self(1 << 7);
pub const NODUMP: Self = Self(1 << 8);
pub const NOATIME: Self = Self(1 << 9);
pub const DIRSYNC: Self = Self(1 << 10);
pub const COMPRESS: Self = Self(1 << 11);
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[non_exhaustive]
pub struct InodeItem {
pub generation: u64,
pub transid: u64,
pub size: u64,
pub nbytes: u64,
pub block_group: u64,
pub nlink: u32,
pub uid: u32,
pub gid: u32,
pub mode: u32,
pub rdev: u64,
pub flags: InodeFlags,
pub sequence: u64,
pub atime: Timestamp,
pub ctime: Timestamp,
pub mtime: Timestamp,
pub otime: Timestamp,
}
impl InodeItem {
pub const SIZE: usize = 160;
pub const MODE_TYPE_MASK: u32 = 0o170000;
pub const MINOR_BITS: u32 = 20;
pub const MINOR_MASK: u32 = (1 << Self::MINOR_BITS) - 1;
pub fn read_from(buf: &[u8]) -> Result<Self, ParseError> {
if buf.len() < Self::SIZE {
return Err(ParseError::TooShort {
structure: "btrfs_inode_item",
need: Self::SIZE,
got: buf.len(),
});
}
Ok(Self {
generation: get_u64(buf, 0),
transid: get_u64(buf, 8),
size: get_u64(buf, 16),
nbytes: get_u64(buf, 24),
block_group: get_u64(buf, 32),
nlink: get_u32(buf, 40),
uid: get_u32(buf, 44),
gid: get_u32(buf, 48),
mode: get_u32(buf, 52),
rdev: get_u64(buf, 56),
flags: InodeFlags::from_bits(get_u64(buf, 64)),
sequence: get_u64(buf, 72),
atime: read_timespec(buf, 112),
ctime: read_timespec(buf, 124),
mtime: read_timespec(buf, 136),
otime: read_timespec(buf, 148),
})
}
pub fn write_to(&self, buf: &mut [u8]) {
assert!(
buf.len() >= Self::SIZE,
"an inode item needs {} bytes and was given {}",
Self::SIZE,
buf.len()
);
put_u64(buf, 0, self.generation);
put_u64(buf, 8, self.transid);
put_u64(buf, 16, self.size);
put_u64(buf, 24, self.nbytes);
put_u64(buf, 32, self.block_group);
put_u32(buf, 40, self.nlink);
put_u32(buf, 44, self.uid);
put_u32(buf, 48, self.gid);
put_u32(buf, 52, self.mode);
put_u64(buf, 56, self.rdev);
put_u64(buf, 64, self.flags.bits());
put_u64(buf, 72, self.sequence);
write_timespec(buf, 112, self.atime);
write_timespec(buf, 124, self.ctime);
write_timespec(buf, 136, self.mtime);
write_timespec(buf, 148, self.otime);
}
#[must_use]
pub const fn mode_type(&self) -> u32 {
self.mode & Self::MODE_TYPE_MASK
}
#[must_use]
pub const fn device(&self) -> (u32, u32) {
let raw = self.rdev as u32;
(raw >> Self::MINOR_BITS, raw & Self::MINOR_MASK)
}
#[must_use]
pub const fn encode_device(major: u32, minor: u32) -> u64 {
((major << Self::MINOR_BITS) | (minor & Self::MINOR_MASK)) as u64
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct InodeRef {
pub index: u64,
pub name_len: u16,
}
impl InodeRef {
pub const SIZE: usize = 10;
pub fn read_from(buf: &[u8]) -> Result<Self, ParseError> {
if buf.len() < Self::SIZE {
return Err(ParseError::TooShort {
structure: "btrfs_inode_ref",
need: Self::SIZE,
got: buf.len(),
});
}
Ok(Self {
index: get_u64(buf, 0),
name_len: get_u16(buf, 8),
})
}
pub fn write_to(&self, buf: &mut [u8]) {
assert!(
buf.len() >= Self::SIZE,
"an inode ref needs {} bytes and was given {}",
Self::SIZE,
buf.len()
);
put_u64(buf, 0, self.index);
put_u16(buf, 8, self.name_len);
}
}
impl Packed for InodeRef {
const STRUCTURE: &'static str = "btrfs_inode_ref";
const HEAD: usize = Self::SIZE;
fn read_head(buf: &[u8]) -> Result<Self, ParseError> {
Self::read_from(buf)
}
fn encoded_len(&self) -> usize {
Self::SIZE + self.name_len as usize
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct InodeExtref {
pub parent_objectid: u64,
pub index: u64,
pub name_len: u16,
}
impl InodeExtref {
pub const SIZE: usize = 18;
pub fn read_from(buf: &[u8]) -> Result<Self, ParseError> {
if buf.len() < Self::SIZE {
return Err(ParseError::TooShort {
structure: "btrfs_inode_extref",
need: Self::SIZE,
got: buf.len(),
});
}
Ok(Self {
parent_objectid: get_u64(buf, 0),
index: get_u64(buf, 8),
name_len: get_u16(buf, 16),
})
}
pub fn write_to(&self, buf: &mut [u8]) {
assert!(
buf.len() >= Self::SIZE,
"an inode extref needs {} bytes and was given {}",
Self::SIZE,
buf.len()
);
put_u64(buf, 0, self.parent_objectid);
put_u64(buf, 8, self.index);
put_u16(buf, 16, self.name_len);
}
}
impl Packed for InodeExtref {
const STRUCTURE: &'static str = "btrfs_inode_extref";
const HEAD: usize = Self::SIZE;
fn read_head(buf: &[u8]) -> Result<Self, ParseError> {
Self::read_from(buf)
}
fn encoded_len(&self) -> usize {
Self::SIZE + self.name_len as usize
}
}
#[cfg(test)]
mod tests {
use super::super::for_each_packed;
use super::*;
fn an_inode() -> InodeItem {
InodeItem {
generation: 8,
transid: 8,
size: 1234,
nbytes: 4096,
block_group: 0,
nlink: 1,
uid: 1000,
gid: 1000,
mode: 0o100_644,
rdev: 0,
flags: InodeFlags::NONE,
sequence: 3,
atime: Timestamp {
secs: 1_786_392_177,
nanos: 123_456_789,
},
ctime: Timestamp {
secs: 1_786_392_178,
nanos: 0,
},
mtime: Timestamp {
secs: 1_786_392_179,
nanos: 1,
},
otime: Timestamp {
secs: 1_786_392_100,
nanos: 999_999_999,
},
}
}
#[test]
fn an_inode_item_round_trips_through_its_hundred_and_sixty_bytes() {
let inode = an_inode();
let mut buf = [0u8; InodeItem::SIZE];
inode.write_to(&mut buf);
assert_eq!(InodeItem::read_from(&buf).expect("a full item"), inode);
assert_eq!(&buf[16..24], &1234u64.to_le_bytes(), "size");
assert_eq!(&buf[40..44], &1u32.to_le_bytes(), "nlink");
assert_eq!(&buf[52..56], &0o100_644u32.to_le_bytes(), "mode");
assert_eq!(&buf[112..120], &1_786_392_177u64.to_le_bytes(), "atime");
assert_eq!(&buf[120..124], &123_456_789u32.to_le_bytes(), "atime nanos");
}
#[test]
fn the_birth_time_is_a_field_of_its_own_and_survives_the_round_trip() {
let mut buf = [0u8; InodeItem::SIZE];
an_inode().write_to(&mut buf);
assert_eq!(&buf[148..156], &1_786_392_100u64.to_le_bytes());
let read = InodeItem::read_from(&buf).expect("a full item");
assert_eq!(read.otime.secs, 1_786_392_100);
assert_eq!(read.otime.nanos, 999_999_999);
assert_ne!(read.atime, read.mtime);
assert_ne!(read.ctime, read.otime);
}
#[test]
fn the_reserved_words_survive_a_write() {
let mut buf = [0x77u8; InodeItem::SIZE];
an_inode().write_to(&mut buf);
assert!(buf[80..112].iter().all(|&b| b == 0x77));
}
#[test]
fn a_device_number_is_split_the_way_the_kernel_encodes_it() {
let null = InodeItem {
mode: 0o020_666,
rdev: InodeItem::encode_device(1, 3),
..an_inode()
};
assert_eq!(null.rdev, 0x0010_0003, "twenty bits of minor");
assert_eq!(null.device(), (1, 3));
let sda = InodeItem {
mode: 0o060_660,
rdev: InodeItem::encode_device(8, 0),
..an_inode()
};
assert_eq!(sda.device(), (8, 0));
let big = InodeItem {
rdev: InodeItem::encode_device(1, 0xf_ffff),
..an_inode()
};
assert_eq!(big.device(), (1, 0xf_ffff));
}
#[test]
fn a_mode_says_what_the_inode_is_in_its_type_bits() {
assert_eq!(an_inode().mode_type(), 0o100_000);
let dir = InodeItem {
mode: 0o040_755,
..an_inode()
};
assert_eq!(dir.mode_type(), 0o040_000);
}
#[test]
fn an_item_shorter_than_the_format_writes_is_refused() {
assert!(matches!(
InodeItem::read_from(&[0u8; InodeItem::SIZE - 1]),
Err(ParseError::TooShort {
structure: "btrfs_inode_item",
need: 160,
got: 159,
})
));
}
#[test]
fn every_name_an_inode_has_in_one_directory_is_in_one_item() {
let mut data = Vec::new();
for (index, name) in [(2u64, &b"one"[..]), (5, &b"another"[..])] {
let head = InodeRef {
index,
name_len: name.len() as u16,
};
let mut buf = [0u8; InodeRef::SIZE];
head.write_to(&mut buf);
data.extend_from_slice(&buf);
data.extend_from_slice(name);
}
let mut found = Vec::new();
for_each_packed::<InodeRef, _>(&data, |head, name| {
found.push((head.index, name.to_vec()));
true
})
.expect("two names");
assert_eq!(found, vec![(2, b"one".to_vec()), (5, b"another".to_vec())]);
}
#[test]
fn an_extended_ref_carries_the_parent_a_plain_ref_keeps_in_its_key() {
let head = InodeExtref {
parent_objectid: 256,
index: 9,
name_len: 4,
};
let mut data = [0u8; InodeExtref::SIZE + 4];
head.write_to(&mut data);
data[InodeExtref::SIZE..].copy_from_slice(b"name");
assert_eq!(&data[0..8], &256u64.to_le_bytes());
assert_eq!(&data[16..18], &4u16.to_le_bytes());
let mut seen = None;
for_each_packed::<InodeExtref, _>(&data, |head, name| {
seen = Some((head.parent_objectid, name.to_vec()));
true
})
.expect("one name");
assert_eq!(seen, Some((256, b"name".to_vec())));
}
#[test]
fn a_name_longer_than_the_item_holding_it_is_refused() {
let head = InodeRef {
index: 1,
name_len: 40,
};
let mut data = [0u8; InodeRef::SIZE + 4];
head.write_to(&mut data);
assert!(matches!(
for_each_packed::<InodeRef, _>(&data, |_, _| true),
Err(ParseError::TooShort {
structure: "btrfs_inode_ref",
need: 50,
got: 14,
})
));
}
#[test]
fn a_file_with_no_checksums_says_so_in_the_bit_the_format_gives_it() {
let inode = InodeItem {
flags: InodeFlags::NODATASUM | InodeFlags::NODATACOW,
..an_inode()
};
let mut buf = [0u8; InodeItem::SIZE];
inode.write_to(&mut buf);
assert_eq!(&buf[64..72], &3u64.to_le_bytes());
let read = InodeItem::read_from(&buf).expect("a full item");
assert!(read.flags.contains(InodeFlags::NODATASUM));
assert!(!read.flags.contains(InodeFlags::PREALLOC));
}
}