use crate::Timestamp;
use crate::bytes::{get_arr, get_u8, get_u32, get_u64, put_arr, put_u8, put_u32, put_u64};
use crate::flags::flag_set;
use super::{DiskKey, ParseError};
pub const TIMESPEC_SIZE: usize = 12;
#[must_use]
pub fn read_timespec(buf: &[u8], off: usize) -> Timestamp {
Timestamp {
secs: get_u64(buf, off) as i64,
nanos: get_u32(buf, off + 8),
}
}
pub fn write_timespec(buf: &mut [u8], off: usize, time: Timestamp) {
put_u64(buf, off, time.secs as u64);
put_u32(buf, off + 8, time.nanos);
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct RootFlags(u64);
flag_set!(RootFlags: u64);
impl RootFlags {
pub const SUBVOL_RDONLY: Self = Self(1 << 0);
pub const SUBVOL_DEAD: Self = Self(1 << 48);
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[non_exhaustive]
pub struct RootItem {
pub generation: u64,
pub root_dirid: u64,
pub bytenr: u64,
pub byte_limit: u64,
pub bytes_used: u64,
pub last_snapshot: u64,
pub flags: RootFlags,
pub refs: u32,
pub drop_progress: DiskKey,
pub drop_level: u8,
pub level: u8,
pub generation_v2: u64,
pub uuid: [u8; 16],
pub parent_uuid: [u8; 16],
pub received_uuid: [u8; 16],
pub ctransid: u64,
pub otransid: u64,
pub stransid: u64,
pub rtransid: u64,
pub ctime: Timestamp,
pub otime: Timestamp,
pub stime: Timestamp,
pub rtime: Timestamp,
}
impl RootItem {
pub const SIZE: usize = 439;
pub const INODE_LEN: usize = 160;
pub fn read_from(buf: &[u8]) -> Result<Self, ParseError> {
if buf.len() < Self::SIZE {
return Err(ParseError::TooShort {
structure: "btrfs_root_item",
need: Self::SIZE,
got: buf.len(),
});
}
Ok(Self {
generation: get_u64(buf, 160),
root_dirid: get_u64(buf, 168),
bytenr: get_u64(buf, 176),
byte_limit: get_u64(buf, 184),
bytes_used: get_u64(buf, 192),
last_snapshot: get_u64(buf, 200),
flags: RootFlags::from_bits(get_u64(buf, 208)),
refs: get_u32(buf, 216),
drop_progress: DiskKey::read_from(&buf[220..220 + DiskKey::SIZE])?,
drop_level: get_u8(buf, 237),
level: get_u8(buf, 238),
generation_v2: get_u64(buf, 239),
uuid: get_arr(buf, 247),
parent_uuid: get_arr(buf, 263),
received_uuid: get_arr(buf, 279),
ctransid: get_u64(buf, 295),
otransid: get_u64(buf, 303),
stransid: get_u64(buf, 311),
rtransid: get_u64(buf, 319),
ctime: read_timespec(buf, 327),
otime: read_timespec(buf, 339),
stime: read_timespec(buf, 351),
rtime: read_timespec(buf, 363),
})
}
pub fn write_to(&self, buf: &mut [u8]) {
assert!(
buf.len() >= Self::SIZE,
"a root item needs {} bytes and was given {}",
Self::SIZE,
buf.len()
);
put_u64(buf, 160, self.generation);
put_u64(buf, 168, self.root_dirid);
put_u64(buf, 176, self.bytenr);
put_u64(buf, 184, self.byte_limit);
put_u64(buf, 192, self.bytes_used);
put_u64(buf, 200, self.last_snapshot);
put_u64(buf, 208, self.flags.bits());
put_u32(buf, 216, self.refs);
self.drop_progress
.write_to(&mut buf[220..220 + DiskKey::SIZE]);
put_u8(buf, 237, self.drop_level);
put_u8(buf, 238, self.level);
put_u64(buf, 239, self.generation_v2);
put_arr(buf, 247, &self.uuid);
put_arr(buf, 263, &self.parent_uuid);
put_arr(buf, 279, &self.received_uuid);
put_u64(buf, 295, self.ctransid);
put_u64(buf, 303, self.otransid);
put_u64(buf, 311, self.stransid);
put_u64(buf, 319, self.rtransid);
write_timespec(buf, 327, self.ctime);
write_timespec(buf, 339, self.otime);
write_timespec(buf, 351, self.stime);
write_timespec(buf, 363, self.rtime);
}
}
#[cfg(test)]
mod tests {
use super::super::ItemType;
use super::*;
fn a_root_item() -> RootItem {
RootItem {
generation: 5,
root_dirid: 256,
bytenr: 30_441_472,
byte_limit: 0,
bytes_used: 16_384,
last_snapshot: 0,
flags: RootFlags::NONE,
refs: 1,
drop_progress: DiskKey::new(0, ItemType::from_value(0), 0),
drop_level: 0,
level: 0,
generation_v2: 5,
uuid: [0x17; 16],
parent_uuid: [0; 16],
received_uuid: [0; 16],
ctransid: 0,
otransid: 0,
stransid: 0,
rtransid: 0,
ctime: Timestamp {
secs: 1_786_392_177,
nanos: 0,
},
otime: Timestamp {
secs: 1_786_392_177,
nanos: 0,
},
stime: Timestamp::from_secs(0),
rtime: Timestamp::from_secs(0),
}
}
#[test]
fn a_root_item_round_trips_through_its_four_hundred_and_thirty_nine_bytes() {
let item = a_root_item();
let mut buf = [0u8; RootItem::SIZE];
item.write_to(&mut buf);
assert_eq!(RootItem::read_from(&buf).expect("a full item"), item);
assert_eq!(&buf[176..184], &30_441_472u64.to_le_bytes());
assert_eq!(buf[238], 0, "the level");
assert_eq!(&buf[160..168], &5u64.to_le_bytes(), "the generation");
}
#[test]
fn the_unmodelled_halves_survive_a_write() {
let item = a_root_item();
let mut buf = [0x77u8; RootItem::SIZE];
item.write_to(&mut buf);
assert!(buf[..RootItem::INODE_LEN].iter().all(|&b| b == 0x77));
assert!(buf[375..].iter().all(|&b| b == 0x77), "the reserved words");
}
#[test]
fn a_time_before_the_epoch_is_read_as_one() {
let mut buf = [0u8; RootItem::SIZE];
a_root_item().write_to(&mut buf);
write_timespec(
&mut buf,
327,
Timestamp {
secs: -18_000,
nanos: 500,
},
);
let item = RootItem::read_from(&buf).expect("a full item");
assert_eq!(
item.ctime,
Timestamp {
secs: -18_000,
nanos: 500
}
);
}
#[test]
fn an_item_shorter_than_the_format_writes_is_refused_rather_than_completed() {
assert!(matches!(
RootItem::read_from(&[0u8; RootItem::SIZE - 1]),
Err(ParseError::TooShort {
need: 439,
got: 438,
..
})
));
}
#[test]
fn a_read_only_subvolume_says_so_in_the_bit_the_format_gives_it() {
let item = RootItem {
flags: RootFlags::SUBVOL_RDONLY,
..a_root_item()
};
let mut buf = [0u8; RootItem::SIZE];
item.write_to(&mut buf);
assert_eq!(&buf[208..216], &1u64.to_le_bytes());
assert!(
RootItem::read_from(&buf)
.expect("a full item")
.flags
.contains(RootFlags::SUBVOL_RDONLY)
);
}
}