use std::collections::BTreeMap;
use std::io::{Seek, SeekFrom, Write};
use crate::alloc::{AllocError, Allocator};
use crate::csum::{Checksummer, Crc32c, CsumScheme, NullCsum};
use crate::dir::{DirBlock, DirBlockKind, DirError, DirLayout, HtreeDir, LinearDir};
use crate::extent::{
ExtentError, build_leaves, build_tree, node_capacity, plan_tree, tail_offset, write_node,
};
use crate::feature::{FeatureSet, LARGE_FILE_MIN_SIZE, Profile, resize_inode_size};
use crate::geometry::{
BlockRange, GeometryError, GrowReservation, InodeCount, Layout, PlanRequest, ReservedRatio,
plan_layout,
};
use crate::hash::{HashSignedness, HashVersion};
use crate::journal::{self, JournalSize};
use crate::model::{
Content, FIRST_USER_INO, FsModel, LOST_FOUND_INO, ModelConfig, ModelError, ModelInode,
build_model,
};
use crate::ondisk::{
BG_BLOCK_UNINIT, BG_INODE_UNINIT, BG_INODE_ZEROED, DIR_TAIL_LEN, DX_ENTRY_LEN, DX_TAIL_LEN,
DirEntry, GroupDescriptor, Inode, InodeFlags, ParseError, SuperBlock, Timestamp, Xattr,
encode_block, encode_device, encode_inline, extra_isize_for, get_u16, orphan_entries_len,
orphan_tail_bytes, put_u16, put_u32, split_for_storage, write_dir_tail, write_dx_tail,
};
use crate::source::Source;
const RESIZE_INO: u32 = 7;
fn journal_space(e: impl Into<FormatError>) -> FormatError {
match e.into() {
FormatError::Alloc(AllocError::OutOfSpace {
requested,
available,
}) => FormatError::JournalDoesNotFit {
requested,
available,
},
other => other,
}
}
const JOURNAL_INO: u32 = 8;
const ORPHAN_INO: u32 = FIRST_USER_INO;
fn first_user_inode(feature: &FeatureSet) -> u32 {
if feature.has_orphan_file() {
ORPHAN_INO + 1
} else {
FIRST_USER_INO
}
}
fn orphan_file_blocks(total_blocks: u64) -> u32 {
const RATIO: u64 = 4096;
const MIN: u64 = 32;
const MAX: u64 = 512;
(total_blocks / RATIO).clamp(MIN, MAX) as u32
}
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
pub enum ErrorBehavior {
#[default]
Continue,
RemountReadOnly,
Panic,
}
impl ErrorBehavior {
const fn to_s_errors(self) -> u16 {
match self {
Self::Continue => 1,
Self::RemountReadOnly => 2,
Self::Panic => 3,
}
}
}
#[derive(Clone, Copy, Debug)]
#[non_exhaustive]
pub struct FormatOptions {
pub uuid: [u8; 16],
pub time: Timestamp,
pub hash_seed: [u8; 16],
pub hash_version: HashVersion,
pub hash_signedness: HashSignedness,
pub grow: GrowReservation,
pub inodes: InodeCount,
pub reserved: ReservedRatio,
pub volume_name: [u8; 16],
pub feature: FeatureSet,
pub errors: ErrorBehavior,
pub journal: JournalSize,
pub fixed_time: Option<Timestamp>,
}
impl FormatOptions {
fn validate_format_time(&self) -> Result<(), FormatError> {
let secs = self.time.secs;
if secs < 0 || secs > u64::from(u32::MAX) as i64 {
return Err(FormatError::FormatTimeOutOfRange { secs });
}
Ok(())
}
#[must_use]
pub fn new(uuid: [u8; 16], time: Timestamp, hash_seed: [u8; 16]) -> Self {
Self {
uuid,
time,
hash_seed,
hash_version: HashVersion::default(),
hash_signedness: HashSignedness::default(),
grow: GrowReservation::default(),
inodes: InodeCount::default(),
reserved: ReservedRatio::default(),
volume_name: [0; 16],
feature: FeatureSet::default(),
errors: ErrorBehavior::default(),
journal: JournalSize::Auto,
fixed_time: None,
}
}
#[must_use]
pub const fn plan_request(&self, size_bytes: u64) -> PlanRequest {
PlanRequest::new(size_bytes, self.feature)
.grow(self.grow)
.inodes(self.inodes)
.reserved(self.reserved)
}
#[must_use]
pub fn profile(mut self, profile: Profile) -> Self {
self.feature = profile.feature_set();
self
}
}
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum FormatError {
#[error(transparent)]
Io(#[from] std::io::Error),
#[error(transparent)]
Geometry(#[from] GeometryError),
#[error(transparent)]
Model(#[from] ModelError),
#[error(transparent)]
Dir(#[from] DirError),
#[error(transparent)]
Extent(#[from] ExtentError),
#[error(transparent)]
Alloc(#[from] AllocError),
#[error(transparent)]
Parse(#[from] ParseError),
#[error("source needs {needed} inodes but the filesystem has {available}")]
#[non_exhaustive]
TooManyInodes {
needed: u32,
available: u32,
},
#[error("journal of {requested} blocks is below the minimum of {minimum}")]
#[non_exhaustive]
JournalTooSmall {
requested: u32,
minimum: u32,
},
#[error(
"the journal needs {requested} blocks but only {available} are free: build a \
smaller journal, none at all, or a larger filesystem"
)]
#[non_exhaustive]
JournalDoesNotFit {
requested: u64,
available: u64,
},
#[error(
"a filesystem of {blocks} blocks has no room for a journal, which needs at least \
{minimum} blocks: build it without the has_journal feature, or make it larger"
)]
#[non_exhaustive]
FilesystemTooSmallForJournal {
blocks: u64,
minimum: u32,
},
#[error("the {what} is {size} bytes, a large file on a filesystem without large_file")]
#[non_exhaustive]
LargeFileWithoutFeature {
what: &'static str,
size: u64,
},
#[error("the resize inode's 32-bit block map cannot name block {block}")]
#[non_exhaustive]
ResizeMapNeeds32BitBlocks {
block: u64,
},
#[error("the orphan file's inode {inode} is already held by an entry")]
#[non_exhaustive]
OrphanInodeInUse {
inode: u32,
},
#[error(
"an image of {bytes} bytes exceeds what this platform addresses in memory; \
stream it with format_to"
)]
#[non_exhaustive]
ImageTooLargeInMemory {
bytes: u64,
},
#[error("format time of {secs}s is outside the superblock range [0, 2^32) seconds")]
#[non_exhaustive]
FormatTimeOutOfRange {
secs: i64,
},
}
fn map_block(block: u64) -> Result<u32, FormatError> {
u32::try_from(block).map_err(|_| FormatError::ResizeMapNeeds32BitBlocks { block })
}
const DIRECT_BLOCKS: usize = 12;
const INDIRECT_LEVELS: usize = 3;
pub struct Image {
bytes: Vec<u8>,
layout: Layout,
}
impl Image {
#[must_use]
pub fn as_bytes(&self) -> &[u8] {
&self.bytes
}
#[must_use]
pub fn into_bytes(self) -> Vec<u8> {
self.bytes
}
#[must_use]
pub fn layout(&self) -> &Layout {
&self.layout
}
pub fn write_to(&self, mut w: impl std::io::Write) -> std::io::Result<()> {
w.write_all(&self.bytes)
}
}
pub fn format(
source: impl Source,
size_bytes: u64,
options: FormatOptions,
) -> Result<Image, FormatError> {
let plan = FormatPlan::new(source, size_bytes, options)?;
let image_bytes = plan.layout.total_blocks * u64::from(plan.layout.block_size);
let len = usize::try_from(image_bytes)
.map_err(|_| FormatError::ImageTooLargeInMemory { bytes: image_bytes })?;
let mut sink = std::io::Cursor::new(vec![0u8; len]);
let layout = plan.write_to(&mut sink)?;
Ok(Image {
bytes: sink.into_inner(),
layout,
})
}
pub fn format_to(
source: impl Source,
size_bytes: u64,
options: FormatOptions,
mut sink: impl Write + Seek,
) -> Result<Layout, FormatError> {
FormatPlan::new(source, size_bytes, options)?.write_to(&mut sink)
}
pub struct FormatPlan {
layout: Layout,
model: FsModel,
options: FormatOptions,
journal_blocks: Option<u32>,
}
impl FormatPlan {
pub fn new(
source: impl Source,
size_bytes: u64,
options: FormatOptions,
) -> Result<Self, FormatError> {
options.validate_format_time()?;
let feature = options.feature;
let layout = plan_layout(&options.plan_request(size_bytes))?;
let mut config = ModelConfig::new(feature, first_user_inode(&feature), options.time);
config.fixed_time = options.fixed_time;
let model = build_model(source, config)?;
if model.used_inode_count() > layout.total_inodes {
return Err(FormatError::TooManyInodes {
needed: model.used_inode_count(),
available: layout.total_inodes,
});
}
let journal_blocks = journal_size(&layout, &options)?;
Ok(Self {
layout,
model,
options,
journal_blocks,
})
}
#[must_use]
pub fn layout(&self) -> &Layout {
&self.layout
}
#[must_use]
pub fn used_inodes(&self) -> u32 {
self.model.used_inode_count()
}
pub fn write_to(self, mut sink: impl Write + Seek) -> Result<Layout, FormatError> {
let Self {
layout,
model,
options,
journal_blocks,
} = self;
let feature = options.feature;
let mut writer = Writer::new(&layout, &feature, options, journal_blocks, &mut sink);
writer.materialize(&model)?;
writer.extend_to_full_size()?;
Ok(layout)
}
}
fn journal_size(layout: &Layout, options: &FormatOptions) -> Result<Option<u32>, FormatError> {
if !options.feature.has_journal() {
return Ok(None);
}
let minimum = journal::MIN_JOURNAL_BLOCKS;
let blocks = match options.journal {
JournalSize::Auto => journal::default_journal_blocks(layout.total_blocks).ok_or(
FormatError::FilesystemTooSmallForJournal {
blocks: layout.total_blocks,
minimum,
},
)?,
JournalSize::Blocks(n) if n >= minimum => n,
JournalSize::Blocks(n) => {
return Err(FormatError::JournalTooSmall {
requested: n,
minimum,
});
}
};
let size = u64::from(blocks) * u64::from(options.feature.block_size);
if size >= LARGE_FILE_MIN_SIZE && !options.feature.has_large_file() {
return Err(FormatError::LargeFileWithoutFeature {
what: "journal",
size,
});
}
Ok(Some(blocks))
}
struct Writer<'a, W> {
layout: &'a Layout,
feature: &'a FeatureSet,
options: FormatOptions,
alloc: Allocator,
sink: W,
written_end: u64,
block_size: usize,
csum: Box<dyn Checksummer>,
dir: Box<dyn DirLayout>,
inodes: BTreeMap<u32, Inode>,
gdt_bytes: Vec<u8>,
journal_backup: Option<[u32; 17]>,
journal_blocks: Option<u32>,
}
impl<'a, W: Write + Seek> Writer<'a, W> {
fn new(
layout: &'a Layout,
feature: &'a FeatureSet,
options: FormatOptions,
journal_blocks: Option<u32>,
sink: W,
) -> Self {
let block_size = layout.block_size as usize;
let csum: Box<dyn Checksummer> = if feature.has_metadata_csum() {
Box::new(Crc32c::new(&options.uuid))
} else {
Box::new(NullCsum)
};
let dir: Box<dyn DirLayout> = if feature.has_dir_index() {
Box::new(HtreeDir {
seed: options.hash_seed,
version: options.hash_version,
signedness: options.hash_signedness,
checksums: feature.has_metadata_csum(),
})
} else {
Box::new(LinearDir {
tail_len: if feature.has_metadata_csum() {
DIR_TAIL_LEN
} else {
0
},
})
};
Self {
layout,
feature,
options,
alloc: Allocator::new(layout),
sink,
written_end: 0,
block_size,
csum,
dir,
inodes: BTreeMap::new(),
gdt_bytes: Vec::new(),
journal_backup: None,
journal_blocks,
}
}
fn materialize(&mut self, model: &FsModel) -> Result<(), FormatError> {
for minode in model.inodes.values() {
let inode = self.materialize_inode(minode)?;
self.inodes.insert(minode.number, inode);
}
self.materialize_reserved_inodes()?;
self.write_inode_tables()?;
self.write_bitmaps_and_descriptors(model)?;
self.write_superblocks(model)?;
Ok(())
}
fn write_at(&mut self, offset: u64, bytes: &[u8]) -> Result<(), FormatError> {
self.sink.seek(SeekFrom::Start(offset))?;
self.sink.write_all(bytes)?;
self.written_end = self.written_end.max(offset + bytes.len() as u64);
Ok(())
}
fn extend_to_full_size(&mut self) -> Result<(), FormatError> {
let size = self.layout.total_blocks * u64::from(self.layout.block_size);
if self.written_end < size {
self.write_at(size - 1, &[0])?;
}
Ok(())
}
fn new_inode(&self) -> Inode {
Inode::empty(self.feature.inode_size)
}
fn stamp_structural_times(&self, inode: &mut Inode) {
let t = self.options.fixed_time.unwrap_or(self.options.time);
inode.atime = t;
inode.ctime = t;
inode.mtime = t;
inode.crtime = t;
}
fn materialize_inode(&mut self, minode: &ModelInode) -> Result<Inode, FormatError> {
let mut inode = self.new_inode();
inode.mode = minode.mode;
inode.uid = minode.uid;
inode.gid = minode.gid;
inode.links_count = minode.links_count;
inode.atime = minode.atime;
inode.ctime = minode.ctime;
inode.mtime = minode.mtime;
inode.crtime = minode.crtime;
match &minode.content {
Content::Directory(children) => {
let entries: Vec<DirEntry> = children
.iter()
.map(|c| DirEntry {
inode: c.inode,
file_type: c.file_type,
name: c.name.clone(),
})
.collect();
let mut blocks = self.dir.build_blocks(&entries, self.block_size)?;
if minode.number == LOST_FOUND_INO {
let min_blocks = (16 * 1024usize).div_ceil(self.block_size);
while blocks.len() < min_blocks {
blocks.push(DirBlock {
bytes: self.empty_dir_block(),
kind: DirBlockKind::Entries,
});
}
}
let indexed = blocks
.iter()
.any(|b| matches!(b.kind, DirBlockKind::Index { .. }));
self.write_dir_checksums(minode.number, &mut blocks);
let bytes: Vec<Vec<u8>> = blocks.into_iter().map(|b| b.bytes).collect();
self.place_blocks(minode.number, &mut inode, &bytes)?;
if indexed {
inode.flags = inode.flags | InodeFlags::INDEX;
}
}
Content::File(content) => {
let bytes = content.read()?;
let blocks = chunk_into_blocks(&bytes, self.block_size);
self.place_blocks(minode.number, &mut inode, &blocks)?;
inode.size = content.len();
}
Content::SlowSymlink(target) => {
let blocks = chunk_into_blocks(target, self.block_size);
self.place_blocks(minode.number, &mut inode, &blocks)?;
inode.size = target.len() as u64;
}
Content::FastSymlink(target) => {
inode.block[..target.len()].copy_from_slice(target);
inode.size = target.len() as u64;
}
Content::Device { major, minor } => {
let (b0, b1) = encode_device(*major, *minor);
put_u32(&mut inode.block, 0, b0);
put_u32(&mut inode.block, 4, b1);
}
Content::Special => {
}
}
self.encode_xattrs(&mut inode, &minode.xattrs)?;
Ok(inode)
}
fn encode_xattrs(&mut self, inode: &mut Inode, xattrs: &[Xattr]) -> Result<(), FormatError> {
if xattrs.is_empty() {
return Ok(());
}
let region_len = inode.inline_xattr_capacity(self.feature.inode_size);
let (inline, spilled) = split_for_storage(xattrs, region_len);
if !inline.is_empty() {
inode.inline_xattr = encode_inline(&inline, region_len)
.expect("the inline side of the split fits the region by construction");
}
if !spilled.is_empty() {
let signed = matches!(self.options.hash_signedness, HashSignedness::Signed);
let mut block = encode_block(&spilled, self.block_size, signed);
let phys = self.alloc.allocate_one()?;
if self.csum.scheme().writes_object_checksums() {
let mut c = self.csum.crc32c(self.csum.base_seed(), &phys.to_le_bytes());
c = self.csum.crc32c(c, &block);
put_u32(&mut block, 16, c);
}
self.write_block(phys, &block)?;
inode.file_acl = phys;
inode.blocks += self.sectors_per_block();
}
Ok(())
}
fn place_blocks(
&mut self,
ino: u32,
inode: &mut Inode,
blocks: &[Vec<u8>],
) -> Result<(), FormatError> {
if self.feature.has_extents() {
inode.flags = InodeFlags::EXTENTS;
let ranges = self.alloc.allocate(blocks.len() as u64)?;
let physical = flatten(&ranges);
for (data, &phys) in blocks.iter().zip(&physical) {
self.write_block(phys, data)?;
}
let meta = self.root_extent_tree(ino, inode, &ranges)?;
inode.blocks = (blocks.len() as u64 + meta) * self.sectors_per_block();
} else {
let physical = self.build_classic_map(inode, blocks.len())?;
for (data, &phys) in blocks.iter().zip(&physical) {
self.write_block(phys, data)?;
}
}
if inode.size == 0 {
inode.size = (blocks.len() * self.block_size) as u64;
}
Ok(())
}
fn build_classic_map(&mut self, inode: &mut Inode, n: usize) -> Result<Vec<u64>, FormatError> {
inode.flags = InodeFlags::NONE;
let mut physical = Vec::with_capacity(n);
let mut meta = 0u64;
for slot in 0..n.min(DIRECT_BLOCKS) {
let phys = self.alloc.allocate_one()?;
physical.push(phys);
put_u32(&mut inode.block, slot * 4, map_block(phys)?);
}
for level in 1..=INDIRECT_LEVELS {
if physical.len() >= n {
break;
}
let root = self.build_indirect(level as u32, n, &mut physical, &mut meta)?;
put_u32(
&mut inode.block,
(DIRECT_BLOCKS + level - 1) * 4,
map_block(root)?,
);
}
inode.blocks = (n as u64 + meta) * self.sectors_per_block();
Ok(physical)
}
fn build_indirect(
&mut self,
level: u32,
n: usize,
physical: &mut Vec<u64>,
meta: &mut u64,
) -> Result<u64, FormatError> {
let ind_block = self.alloc.allocate_one()?;
*meta += 1;
let ppb = self.block_size / 4;
let mut ptrs = vec![0u8; self.block_size];
for slot in 0..ppb {
if physical.len() >= n {
break;
}
let child = if level == 1 {
let phys = self.alloc.allocate_one()?;
physical.push(phys);
phys
} else {
self.build_indirect(level - 1, n, physical, meta)?
};
put_u32(&mut ptrs, slot * 4, map_block(child)?);
}
self.write_block(ind_block, &ptrs)?;
Ok(ind_block)
}
fn root_extent_tree(
&mut self,
ino: u32,
inode: &mut Inode,
ranges: &[BlockRange],
) -> Result<u64, FormatError> {
let inline_capacity = node_capacity(Inode::BLOCK_BYTES);
let node_capacity = node_capacity(self.block_size);
let leaves = build_leaves(ranges)?;
let shape = plan_tree(leaves.len(), inline_capacity, node_capacity)?;
let mut node_blocks = Vec::with_capacity(shape.node_blocks);
for _ in 0..shape.node_blocks {
node_blocks.push(self.alloc.allocate_one()?);
}
let tree = build_tree(&leaves, inline_capacity, node_capacity, &node_blocks)?;
for node in &tree.nodes {
let mut buf = vec![0u8; self.block_size];
write_node(&node.node, node_capacity, &mut buf)?;
self.write_extent_node_checksum(ino, &mut buf);
self.write_block(node.block, &buf)?;
}
write_node(&tree.root, inline_capacity, &mut inode.block)?;
Ok(shape.node_blocks as u64)
}
fn write_extent_node_checksum(&self, ino: u32, buf: &mut [u8]) {
if !self.csum.scheme().writes_object_checksums() {
return;
}
let tail = tail_offset(self.block_size);
let mut c = self.csum.crc32c(self.csum.base_seed(), &ino.to_le_bytes());
c = self.csum.crc32c(c, &0u32.to_le_bytes());
c = self.csum.crc32c(c, &buf[..tail]);
put_u32(buf, tail, c);
}
fn empty_dir_block(&self) -> Vec<u8> {
let tail_len = if self.csum.scheme().writes_object_checksums() {
DIR_TAIL_LEN
} else {
0
};
let usable = self.block_size - tail_len;
let mut block = vec![0u8; self.block_size];
put_u32(&mut block, 0, 0); put_u16(&mut block, 4, usable as u16); if tail_len != 0 {
write_dir_tail(&mut block[usable..usable + DIR_TAIL_LEN], 0)
.expect("tail slice is exactly DIR_TAIL_LEN");
}
block
}
fn write_dir_checksums(&self, dir_ino: u32, blocks: &mut [DirBlock]) {
if !self.csum.scheme().writes_object_checksums() {
return;
}
let seed = self.csum.base_seed();
for block in blocks {
let mut c = self.csum.crc32c(seed, &dir_ino.to_le_bytes());
c = self.csum.crc32c(c, &0u32.to_le_bytes());
match block.kind {
DirBlockKind::Entries => {
let covered = self.block_size - DIR_TAIL_LEN;
c = self.csum.crc32c(c, &block.bytes[..covered]);
put_u32(&mut block.bytes, self.block_size - 4, c);
}
DirBlockKind::Index {
count_offset,
limit,
} => {
let count = get_u16(&block.bytes, count_offset + 2) as usize;
let covered = count_offset + DX_ENTRY_LEN * count;
c = self.csum.crc32c(c, &block.bytes[..covered]);
c = self.csum.crc32c(c, &[0u8; DX_TAIL_LEN]);
write_dx_tail(&mut block.bytes, count_offset, limit, c)
.expect("the index block reserved its tail");
}
}
}
}
fn materialize_reserved_inodes(&mut self) -> Result<(), FormatError> {
for n in [1u32, 3, 4, 5, 6, 9, 10] {
self.inodes.insert(n, self.new_inode());
}
let resize = if self.feature.has_resize_inode() {
self.materialize_resize_inode()?
} else {
self.new_inode()
};
self.inodes.insert(RESIZE_INO, resize);
let journal = match self.journal_blocks {
Some(blocks) => self.materialize_journal_inode(blocks)?,
None => self.new_inode(),
};
self.inodes.insert(JOURNAL_INO, journal);
if self.feature.has_orphan_file() {
if self.inodes.contains_key(&ORPHAN_INO) {
return Err(FormatError::OrphanInodeInUse { inode: ORPHAN_INO });
}
let orphan = self.materialize_orphan_inode()?;
self.inodes.insert(ORPHAN_INO, orphan);
}
Ok(())
}
fn materialize_orphan_inode(&mut self) -> Result<Inode, FormatError> {
let blocks = orphan_file_blocks(self.layout.total_blocks);
let ranges = match self.alloc.allocate_contiguous(u64::from(blocks)) {
Some(range) => vec![range],
None => self.alloc.allocate(u64::from(blocks))?,
};
let mut inode = self.new_inode();
inode.mode = 0o100600;
inode.links_count = 1;
self.stamp_structural_times(&mut inode);
inode.flags = InodeFlags::EXTENTS;
let meta = self.root_extent_tree(ORPHAN_INO, &mut inode, &ranges)?;
inode.size = u64::from(blocks) * u64::from(self.feature.block_size);
inode.blocks = (u64::from(blocks) + meta) * self.sectors_per_block();
let entries_len = orphan_entries_len(self.block_size);
let entries = vec![0u8; entries_len];
let seed = self.csum.base_seed();
for block in ranges.iter().flat_map(|r| r.start..r.start + r.len) {
let mut c = self.csum.crc32c(seed, &ORPHAN_INO.to_le_bytes());
c = self.csum.crc32c(c, &inode.generation.to_le_bytes());
c = self.csum.crc32c(c, &block.to_le_bytes());
c = self.csum.crc32c(c, &entries);
let offset = block * u64::from(self.layout.block_size) + entries_len as u64;
self.write_at(offset, &orphan_tail_bytes(c))?;
}
Ok(inode)
}
fn materialize_journal_inode(&mut self, blocks: u32) -> Result<Inode, FormatError> {
let size = u64::from(blocks) * u64::from(self.feature.block_size);
let sb = journal::build_superblock(&journal::JournalParams::new(
self.feature.block_size,
blocks,
self.options.uuid,
));
let mut inode = self.new_inode();
inode.mode = 0o100600;
inode.links_count = 1;
self.stamp_structural_times(&mut inode);
if self.feature.has_extents() {
let ranges = match self.alloc.allocate_contiguous(u64::from(blocks)) {
Some(range) => vec![range],
None => self
.alloc
.allocate(u64::from(blocks))
.map_err(journal_space)?,
};
self.write_block(ranges[0].start, &sb)?;
inode.flags = InodeFlags::EXTENTS;
let meta = self.root_extent_tree(JOURNAL_INO, &mut inode, &ranges)?;
inode.blocks = (u64::from(blocks) + meta) * self.sectors_per_block();
} else {
let physical = self
.build_classic_map(&mut inode, blocks as usize)
.map_err(journal_space)?;
self.write_block(physical[0], &sb)?;
}
inode.size = size;
let mut backup = [0u32; 17];
for (i, word) in inode.block.chunks_exact(4).enumerate() {
backup[i] = u32::from_le_bytes([word[0], word[1], word[2], word[3]]);
}
backup[15] = (inode.size >> 32) as u32;
backup[16] = inode.size as u32;
self.journal_backup = Some(backup);
Ok(inode)
}
fn materialize_resize_inode(&mut self) -> Result<Inode, FormatError> {
let mut inode = self.new_inode();
inode.mode = 0o100600;
inode.links_count = 1;
self.stamp_structural_times(&mut inode);
inode.flags = InodeFlags::NONE;
let reserved = self.layout.reserved_gdt_blocks;
let bs = self.block_size;
let fdb = u64::from(self.layout.first_data_block);
let gdt = u64::from(self.layout.gdt_blocks);
let backups = self.layout.backup_groups();
let slots = u64::from(self.layout.block_size) / 4;
let dind_block = self.alloc.allocate_one()?;
let mut dind = vec![0u8; bs];
for r in 0..u64::from(reserved) {
let primary = fdb + 1 + gdt + r; let slot = (gdt + r) % slots;
put_u32(&mut dind, (slot * 4) as usize, map_block(primary)?);
}
self.write_block(dind_block, &dind)?;
for r in 0..u64::from(reserved) {
let ind_block = fdb + 1 + gdt + r;
let mut ind = vec![0u8; bs];
for (j, &bg) in backups.iter().enumerate() {
let start = fdb + u64::from(bg) * u64::from(self.layout.blocks_per_group);
let backup_resv = start + 1 + gdt + r;
put_u32(&mut ind, j * 4, map_block(backup_resv)?);
}
self.write_block(ind_block, &ind)?;
}
inode.size = resize_inode_size(self.layout.block_size);
let data_blocks = 1 + u64::from(reserved) + u64::from(reserved) * backups.len() as u64;
inode.blocks = data_blocks * self.sectors_per_block();
put_u32(&mut inode.block, 13 * 4, map_block(dind_block)?);
Ok(inode)
}
fn write_inode_tables(&mut self) -> Result<(), FormatError> {
let ipg = self.layout.inodes_per_group;
let inode_size = self.feature.inode_size;
let isize = inode_size as usize;
let writes_checksums = self.csum.scheme().writes_object_checksums();
let seed = self.csum.base_seed();
let inodes = std::mem::take(&mut self.inodes);
let mut bytes = vec![0u8; isize];
for (&number, inode) in &inodes {
let group = (number - 1) / ipg;
let index = ((number - 1) % ipg) as usize;
let table = self.layout.groups[group as usize].inode_table;
let offset = table * u64::from(self.layout.block_size) + (index * isize) as u64;
if !writes_checksums && inode.mode == 0 && inode.links_count == 0 {
bytes.iter_mut().for_each(|b| *b = 0);
self.write_at(offset, &bytes)?;
continue;
}
inode.write_to(&mut bytes, inode_size)?;
if writes_checksums {
let mut c = self.csum.crc32c(seed, &number.to_le_bytes());
c = self.csum.crc32c(c, &inode.generation.to_le_bytes());
c = self.csum.crc32c(c, &bytes);
put_u16(&mut bytes, Inode::CHECKSUM_LO_OFFSET, (c & 0xffff) as u16);
if Inode::has_checksum_hi(inode_size, inode.extra_isize) {
put_u16(&mut bytes, Inode::CHECKSUM_HI_OFFSET, (c >> 16) as u16);
}
}
self.write_at(offset, &bytes)?;
}
self.inodes = inodes;
Ok(())
}
fn write_bitmaps_and_descriptors(&mut self, model: &FsModel) -> Result<(), FormatError> {
let ipg = self.layout.inodes_per_group;
let desc_size = self.feature.desc_size() as usize;
let mut gdt_bytes = vec![0u8; self.layout.gdt_blocks as usize * self.block_size];
let mut dir_counts = vec![0u32; self.layout.group_count as usize];
for minode in model.inodes.values() {
if minode.is_dir() {
dir_counts[((minode.number - 1) / ipg) as usize] += 1;
}
}
let uninit_bg = self.csum.scheme().uninit_bg_semantics();
let last_group = self.layout.group_count - 1;
let seed = self.csum.base_seed();
let bb_len = (self.layout.blocks_per_group / 8) as usize;
let ib_len = ipg.div_ceil(8) as usize;
for g in 0..self.layout.group_count {
let gl = &self.layout.groups[g as usize];
let used_inodes = used_inodes_in_group(g, ipg, model.first_free_inode);
let inode_uninit = uninit_bg && used_inodes == 0;
let block_uninit = uninit_bg
&& !self.layout.is_flex_head(g)
&& g != last_group
&& self.group_is_dataless(g);
let bbmp = if block_uninit {
vec![0u8; self.block_size]
} else {
self.alloc
.group_bitmap(g)
.expect("a group of this layout has a bitmap")
.to_vec()
};
let ibmp = if inode_uninit {
vec![0u8; self.block_size]
} else {
self.inode_bitmap(g, model.first_free_inode)
};
let block_bitmap_csum = if block_uninit {
0
} else {
self.csum.crc32c(seed, &bbmp[..bb_len])
};
let inode_bitmap_csum = if inode_uninit {
0
} else {
self.csum.crc32c(seed, &ibmp[..ib_len])
};
let mut flags = if uninit_bg { BG_INODE_ZEROED } else { 0 };
if inode_uninit {
flags |= BG_INODE_UNINIT;
}
if block_uninit {
flags |= BG_BLOCK_UNINIT;
}
let mut desc = GroupDescriptor {
block_bitmap: gl.block_bitmap,
inode_bitmap: gl.inode_bitmap,
inode_table: gl.inode_table,
free_blocks_count: self.alloc.group_free_count(g),
free_inodes_count: ipg - used_inodes,
used_dirs_count: dir_counts[g as usize],
flags,
itable_unused: if uninit_bg { ipg - used_inodes } else { 0 },
checksum: 0,
block_bitmap_csum,
inode_bitmap_csum,
};
desc.checksum = self.group_desc_csum(g, &desc, desc_size);
let off = g as usize * desc_size;
desc.write_to(&mut gdt_bytes[off..off + desc_size], desc_size)
.expect("descriptor buffer is sized to the whole table");
self.write_block(gl.block_bitmap, &bbmp)?;
self.write_block(gl.inode_bitmap, &ibmp)?;
}
let gdt_start =
(u64::from(self.layout.first_data_block) + 1) * u64::from(self.layout.block_size);
self.write_at(gdt_start, &gdt_bytes)?;
self.gdt_bytes = gdt_bytes;
Ok(())
}
fn group_is_dataless(&self, g: u32) -> bool {
let block_count = u64::from(self.layout.groups[g as usize].block_count);
let free = u64::from(self.alloc.group_free_count(g));
let meta = self.layout.super_overhead_region(g).map_or(0, |r| r.len);
block_count - free == meta
}
fn group_desc_csum(&self, group: u32, desc: &GroupDescriptor, desc_size: usize) -> u16 {
match self.csum.scheme() {
CsumScheme::None => return 0,
CsumScheme::Crc32c => {}
}
let mut buf = [0u8; GroupDescriptor::SIZE_64];
desc.write_to(&mut buf[..desc_size], desc_size)
.expect("descriptor buffer holds a full descriptor");
let mut c = self
.csum
.crc32c(self.csum.base_seed(), &group.to_le_bytes());
c = self.csum.crc32c(c, &buf[..desc_size]);
(c & 0xffff) as u16
}
fn inode_bitmap(&self, group: u32, first_free_inode: u32) -> Vec<u8> {
let ipg = self.layout.inodes_per_group;
let mut bmp = vec![0u8; self.block_size];
let base = u64::from(group) * u64::from(ipg);
for i in 0..ipg {
let inode = base + u64::from(i) + 1;
if inode < u64::from(first_free_inode) {
bmp[(i / 8) as usize] |= 1 << (i % 8);
}
}
for i in ipg..(self.block_size as u32 * 8) {
bmp[(i / 8) as usize] |= 1 << (i % 8);
}
bmp
}
fn write_superblocks(&mut self, model: &FsModel) -> Result<(), FormatError> {
let sb = self.build_superblock(model);
let mut primary = sb.to_bytes();
self.finalize_sb_csum(&mut primary);
self.write_at(1024, &primary)?;
let gdt = std::mem::take(&mut self.gdt_bytes);
for g in self.layout.backup_groups() {
let start = (u64::from(self.layout.first_data_block)
+ u64::from(g) * u64::from(self.layout.blocks_per_group))
* u64::from(self.layout.block_size);
let mut backup = sb.clone();
backup.block_group_nr = g as u16;
let mut bytes = backup.to_bytes();
self.finalize_sb_csum(&mut bytes);
self.write_at(start, &bytes)?;
self.write_at(start + u64::from(self.layout.block_size), &gdt)?;
}
Ok(())
}
fn finalize_sb_csum(&self, bytes: &mut [u8; SuperBlock::SIZE]) {
let c = self.csum.crc32c(!0, &bytes[..SuperBlock::SIZE - 4]);
put_u32(bytes, SuperBlock::SIZE - 4, c);
}
fn build_superblock(&self, model: &FsModel) -> SuperBlock {
let mut sb = SuperBlock::new();
let l = self.layout;
sb.inodes_count = l.total_inodes;
sb.blocks_count = l.total_blocks;
sb.r_blocks_count = l.reserved_blocks;
sb.free_blocks_count = self.alloc.free_count();
sb.free_inodes_count = l.total_inodes - model.used_inode_count();
sb.first_data_block = l.first_data_block;
sb.log_block_size = l.block_size.trailing_zeros() - 10;
sb.log_cluster_size = sb.log_block_size;
sb.blocks_per_group = l.blocks_per_group;
sb.clusters_per_group = l.blocks_per_group;
sb.inodes_per_group = l.inodes_per_group;
sb.wtime = self.options.time.secs as u32;
sb.max_mnt_count = 0xffff;
sb.state = 1; sb.errors = self.options.errors.to_s_errors();
sb.lastcheck = self.options.time.secs as u32;
sb.rev_level = 1; sb.first_ino = 11;
sb.inode_size = self.feature.inode_size;
sb.feature_compat = self.feature.compat.bits();
sb.feature_incompat = self.feature.incompat.bits();
sb.feature_ro_compat = self.feature.ro_compat.bits();
sb.uuid = self.options.uuid;
sb.volume_name = self.options.volume_name;
if let Some(backup) = self.journal_backup {
sb.journal_inum = JOURNAL_INO;
sb.jnl_backup_type = 1; sb.jnl_blocks = backup;
}
if self.feature.has_orphan_file() {
sb.orphan_file_inum = ORPHAN_INO;
}
if self.feature.has_csum_seed() {
sb.checksum_seed = self.csum.base_seed();
}
sb.reserved_gdt_blocks = l.reserved_gdt_blocks as u16;
sb.hash_seed = self.options.hash_seed;
sb.def_hash_version = self.options.hash_version.to_u8();
sb.flags = self.options.hash_signedness.to_flag();
sb.desc_size = if self.feature.is_64bit() {
self.feature.desc_size()
} else {
0
};
sb.default_mount_opts = 0x0c; sb.mkfs_time = self.options.time.secs as u32;
sb.min_extra_isize = extra_isize_for(self.feature.inode_size);
sb.want_extra_isize = sb.min_extra_isize;
sb.log_groups_per_flex = if self.feature.has_flex_bg() {
l.flex_bg_size.trailing_zeros() as u8
} else {
0
};
sb.checksum_type = match self.csum.scheme() {
CsumScheme::None => 0,
CsumScheme::Crc32c => 1,
};
let journal_blocks = if self.feature.has_journal() {
self.inodes
.get(&JOURNAL_INO)
.map_or(0, |journal| journal.blocks / self.sectors_per_block())
} else {
0
};
sb.overhead_clusters =
u32::try_from(l.overhead_blocks() + journal_blocks).unwrap_or(u32::MAX);
sb
}
fn sectors_per_block(&self) -> u64 {
u64::from(self.layout.block_size) / 512
}
fn write_block(&mut self, block: u64, data: &[u8]) -> Result<(), FormatError> {
self.write_at(block * u64::from(self.layout.block_size), data)
}
}
fn chunk_into_blocks(bytes: &[u8], block_size: usize) -> Vec<Vec<u8>> {
if bytes.is_empty() {
return Vec::new();
}
bytes
.chunks(block_size)
.map(|chunk| {
let mut block = vec![0u8; block_size];
block[..chunk.len()].copy_from_slice(chunk);
block
})
.collect()
}
fn flatten(ranges: &[BlockRange]) -> Vec<u64> {
let mut out = Vec::new();
for r in ranges {
out.extend(r.start..r.end());
}
out
}
fn used_inodes_in_group(group: u32, ipg: u32, first_free_inode: u32) -> u32 {
let base = group * ipg; (first_free_inode - 1).saturating_sub(base).min(ipg)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::read::Reader;
use crate::source::TreeBuilder;
const MIB: u64 = 1024 * 1024;
fn opts() -> FormatOptions {
let mut o = FormatOptions::new([1u8; 16], Timestamp::from_secs(1_700_000_000), [0u8; 16]);
o.grow = GrowReservation::UpTo(32 * 1024 * MIB);
o
}
#[test]
fn the_profile_setter_seeds_the_matching_feature_set() {
let base = FormatOptions::new([1u8; 16], Timestamp::from_secs(1_700_000_000), [0u8; 16]);
assert_eq!(base.profile(Profile::Ext2).feature, FeatureSet::EXT2);
assert_eq!(base.profile(Profile::Ext3).feature, FeatureSet::EXT3);
assert_eq!(base.profile(Profile::Ext4).feature, FeatureSet::DEFAULT);
let seeded = base.profile(Profile::Ext3);
assert_eq!(seeded.uuid, base.uuid);
assert_eq!(seeded.grow, base.grow);
assert_eq!(seeded.inodes, base.inodes);
}
#[test]
fn a_volume_label_is_written_into_the_superblock_and_reads_back() {
let mut o = opts();
o.volume_name = *b"rootfs\0\0\0\0\0\0\0\0\0\0";
let image = format(TreeBuilder::new(), 64 * MIB, o).expect("format");
assert_eq!(
&image.as_bytes()[1024 + 0x78..1024 + 0x78 + 16],
b"rootfs\0\0\0\0\0\0\0\0\0\0"
);
let reader = Reader::open(std::io::Cursor::new(image.as_bytes())).expect("open");
assert_eq!(
reader.superblock().volume_name,
*b"rootfs\0\0\0\0\0\0\0\0\0\0"
);
let image = format(TreeBuilder::new(), 64 * MIB, opts()).expect("format");
assert_eq!(image.as_bytes()[1024 + 0x78..1024 + 0x78 + 16], [0u8; 16]);
}
#[test]
fn the_error_behavior_reaches_the_superblock_and_reads_back() {
let read_errors = |image: &Image| {
u16::from_le_bytes(
image.as_bytes()[1024 + 0x3c..1024 + 0x3c + 2]
.try_into()
.expect("two bytes"),
)
};
assert_eq!(
read_errors(&format(TreeBuilder::new(), 64 * MIB, opts()).expect("format")),
1,
"the default continues, matching the kernel"
);
for (policy, expected) in [
(ErrorBehavior::Continue, 1u16),
(ErrorBehavior::RemountReadOnly, 2),
(ErrorBehavior::Panic, 3),
] {
let mut o = opts();
o.errors = policy;
let image = format(TreeBuilder::new(), 64 * MIB, o).expect("format");
assert_eq!(
read_errors(&image),
expected,
"{policy:?} in the raw superblock"
);
let reader = Reader::open(std::io::Cursor::new(image.as_bytes())).expect("open");
assert_eq!(reader.superblock().errors, expected, "{policy:?} read back");
}
}
#[test]
fn the_orphan_file_size_follows_the_block_count_between_its_floor_and_ceiling() {
assert_eq!(orphan_file_blocks(2048), 32, "below the floor");
assert_eq!(orphan_file_blocks(131_072), 32, "exactly at the floor");
assert_eq!(orphan_file_blocks(262_144), 64);
assert_eq!(orphan_file_blocks(524_288), 128);
assert_eq!(orphan_file_blocks(2_097_152), 512, "exactly at the ceiling");
assert_eq!(orphan_file_blocks(67_108_864), 512, "above the ceiling");
}
#[test]
fn an_entry_on_the_orphan_files_inode_is_refused() {
let options = opts();
let feature = options.feature;
assert!(feature.has_orphan_file());
let layout = plan_layout(&options.plan_request(64 * MIB)).expect("layout");
let model = build_model(
TreeBuilder::new().file(
b"/f".to_vec(),
b"x".to_vec(),
crate::source::Metadata::new(0o644, options.time),
),
ModelConfig::new(feature, ORPHAN_INO, options.time),
)
.expect("model");
assert!(model.inodes.contains_key(&ORPHAN_INO), "the entry took it");
let mut sink = std::io::Cursor::new(Vec::new());
let journal = journal_size(&layout, &options).expect("the journal size is realizable");
let mut writer = Writer::new(&layout, &feature, options, journal, &mut sink);
let err = writer
.materialize(&model)
.expect_err("the collision is refused");
assert!(
matches!(err, FormatError::OrphanInodeInUse { inode } if inode == ORPHAN_INO),
"expected OrphanInodeInUse, got {err:?}"
);
}
#[test]
fn the_orphan_file_takes_the_inode_below_the_first_entry() {
let with = FeatureSet::default();
assert!(with.has_orphan_file());
assert_eq!(first_user_inode(&with), ORPHAN_INO + 1);
let mut without = FeatureSet::default();
without.compat = crate::feature::Compat::from_bits(
without.compat.bits()
& !(crate::feature::Compat::HAS_JOURNAL.bits()
| crate::feature::Compat::ORPHAN_FILE.bits()),
);
assert_eq!(first_user_inode(&without), FIRST_USER_INO);
}
#[test]
fn the_block_mapped_family_round_trips_direct_and_indirect_files() {
use crate::source::Metadata;
let time = Timestamp::from_secs(1_700_000_000);
let bs = 4096usize;
let direct = vec![0xa1u8; 5 * bs - 17];
let single = vec![0xb2u8; 20 * bs];
let mut double = vec![0u8; 1040 * bs];
for (i, byte) in double.iter_mut().enumerate() {
*byte = (i % 251) as u8;
}
for profile in [Profile::Ext2, Profile::Ext3] {
let src = TreeBuilder::new()
.file(
b"/direct".to_vec(),
direct.clone(),
Metadata::new(0o644, time),
)
.file(
b"/single".to_vec(),
single.clone(),
Metadata::new(0o644, time),
)
.file(
b"/double".to_vec(),
double.clone(),
Metadata::new(0o644, time),
);
let mut o = FormatOptions::new([7u8; 16], time, [0u8; 16]).profile(profile);
o.grow = GrowReservation::UpTo(32 * 1024 * MIB);
let image = format(src, 64 * MIB, o).expect("format block-mapped");
let mut r = Reader::open(std::io::Cursor::new(image.into_bytes())).expect("open");
assert_eq!(
r.profile(),
profile,
"reads back as the family it was written for"
);
for (name, want) in [
(b"/direct".as_slice(), &direct),
(b"/single".as_slice(), &single),
(b"/double".as_slice(), &double),
] {
let (_, inode) = r.lookup(name).expect("lookup");
assert!(
!inode.flags.contains(crate::ondisk::InodeFlags::EXTENTS),
"{profile} {}: block-mapped inode carries no EXTENTS flag",
String::from_utf8_lossy(name)
);
let got = r.read_data(&inode).expect("read");
assert_eq!(got, *want, "{profile} {}", String::from_utf8_lossy(name));
}
}
}
#[test]
fn a_checksum_off_profile_writes_zero_group_flags() {
let mut feature = FeatureSet::default();
feature.ro_compat = crate::feature::RoCompat::from_bits(
feature.ro_compat.bits() & !crate::feature::RoCompat::METADATA_CSUM.bits(),
);
feature.incompat = crate::feature::Incompat::from_bits(
feature.incompat.bits() & !crate::feature::Incompat::CSUM_SEED.bits(),
);
assert!(!feature.has_metadata_csum());
feature.validate().expect("a checksum-off profile is valid");
let mut o = opts();
o.feature = feature;
let image = format(TreeBuilder::new(), 64 * MIB, o).expect("format");
let group_count = image.layout().group_count;
let mut r = Reader::open(std::io::Cursor::new(image.as_bytes())).expect("open");
for g in 0..group_count {
let desc = r.group_descriptor(g).expect("group descriptor");
assert_eq!(
desc.flags, 0,
"group {g}: bg_flags must be zero without metadata_csum"
);
}
}
#[test]
fn the_resize_map_refuses_a_block_past_thirty_two_bits() {
assert_eq!(map_block(0).unwrap(), 0);
assert_eq!(map_block(u64::from(u32::MAX)).unwrap(), u32::MAX);
let err = map_block(u64::from(u32::MAX) + 1).unwrap_err();
assert!(matches!(
err,
FormatError::ResizeMapNeeds32BitBlocks { block } if block == u64::from(u32::MAX) + 1
));
}
#[test]
fn a_format_time_past_the_superblock_range_is_rejected() {
let mut o = opts();
o.time = Timestamp::from_secs(i64::from(u32::MAX) + 1);
let Err(err) = format(TreeBuilder::new(), 64 * MIB, o) else {
panic!("expected FormatTimeOutOfRange");
};
assert!(
matches!(err, FormatError::FormatTimeOutOfRange { secs } if secs == i64::from(u32::MAX) + 1),
"expected FormatTimeOutOfRange, got {err:?}"
);
}
#[test]
fn the_default_max_reservation_formats_and_reads_back() {
let plain = FormatOptions::new([1u8; 16], Timestamp::from_secs(1_700_000_000), [0u8; 16]);
assert_eq!(plain.grow, GrowReservation::Max);
let image = format(TreeBuilder::new(), 64 * MIB, plain).expect("default format");
assert_eq!(
image.layout().reserved_gdt_blocks,
256,
"Max reserves the share of a 64 MiB filesystem it can spare"
);
let mut r = Reader::open(std::io::Cursor::new(image.as_bytes())).expect("open");
let resize = r.inode(7).expect("resize inode");
let dind = u32::from_le_bytes([
resize.block[52],
resize.block[53],
resize.block[54],
resize.block[55],
]);
assert_ne!(
dind, 0,
"the reservation hangs off the double-indirect slot"
);
}
#[test]
fn streaming_a_format_writes_the_same_bytes_as_collecting_one() {
use crate::source::Metadata;
let time = Timestamp::from_secs(1_700_000_000);
let source = || {
TreeBuilder::new()
.directory(b"/etc".to_vec(), Metadata::new(0o755, time))
.file(
b"/etc/hostname".to_vec(),
b"ferrosys\n".to_vec(),
Metadata::new(0o644, time),
)
.symlink(
b"/etc/mtab".to_vec(),
b"/proc/self/mounts".to_vec(),
Metadata::new(0o777, time),
)
};
let collected = format(source(), 64 * MIB, opts()).expect("format");
let mut streamed = std::io::Cursor::new(Vec::new());
let layout = format_to(source(), 64 * MIB, opts(), &mut streamed).expect("format_to");
let streamed = streamed.into_inner();
assert_eq!(layout, *collected.layout());
assert_eq!(
streamed.len(),
collected.as_bytes().len(),
"a streamed image is extended to the filesystem's full size"
);
assert_eq!(streamed, collected.as_bytes(), "the images differ");
}
#[test]
fn a_streamed_image_leaves_the_blocks_it_never_writes_alone() {
let mut sink = std::io::Cursor::new(Vec::new());
let layout = format_to(TreeBuilder::new(), 64 * MIB, opts(), &mut sink).expect("format_to");
let bytes = sink.into_inner();
assert_eq!(
bytes.len() as u64,
layout.total_blocks * u64::from(layout.block_size)
);
let last = bytes.len() - layout.block_size as usize;
assert!(bytes[last..].iter().all(|&b| b == 0));
}
#[test]
fn explicit_journal_size_is_honored() {
let mut o = opts();
o.journal = JournalSize::Blocks(2048);
let image = format(TreeBuilder::new(), 512 * MIB, o).expect("format");
let mut r = Reader::open(std::io::Cursor::new(image.as_bytes())).unwrap();
let jsb = r.journal_superblock().unwrap().expect("journal");
assert_eq!(jsb.max_len, 2048);
assert_eq!(r.inode(8).unwrap().size, 2048 * 4096);
}
#[test]
fn a_journal_past_the_large_file_bound_is_rejected_without_the_feature() {
let mut o = FormatOptions::new([1u8; 16], Timestamp::from_secs(1_700_000_000), [0u8; 16])
.profile(Profile::Ext3);
o.feature.block_size = 1024;
o.feature = o
.feature
.with_feature("large_file", false)
.expect("a known name");
o.grow = GrowReservation::None;
o.journal = JournalSize::Blocks(2 * 1024 * 1024); let Err(err) = format(TreeBuilder::new(), 64 * MIB, o) else {
panic!("expected LargeFileWithoutFeature");
};
assert!(
matches!(
err,
FormatError::LargeFileWithoutFeature {
what: "journal",
size
} if size == 2 * 1024 * MIB
),
"expected LargeFileWithoutFeature for the journal, got {err:?}"
);
let mut o = FormatOptions::new([1u8; 16], Timestamp::from_secs(1_700_000_000), [0u8; 16])
.profile(Profile::Ext3);
o.feature.block_size = 1024;
o.grow = GrowReservation::None;
o.journal = JournalSize::Blocks(2 * 1024 * 1024);
assert!(o.feature.has_large_file());
let Err(err) = format(TreeBuilder::new(), 64 * MIB, o) else {
panic!("a 2 GiB log does not fit a 64 MiB image");
};
assert!(
matches!(err, FormatError::JournalDoesNotFit { .. }),
"the feature check must give way to the space the journal needs, got {err:?}"
);
}
#[test]
fn journal_below_the_minimum_is_rejected() {
let mut o = opts();
o.journal = JournalSize::Blocks(512);
assert!(matches!(
format(TreeBuilder::new(), 512 * MIB, o),
Err(FormatError::JournalTooSmall {
requested: 512,
minimum: 1024
})
));
}
#[test]
fn auto_journal_maps_as_a_single_extent() {
let file = tempfile::tempfile().expect("temp file");
format_to(TreeBuilder::new(), 2048 * MIB, opts(), &file).expect("format");
let mut r = Reader::open(file).unwrap();
let inode = r.inode(8).unwrap();
let entries = u16::from_le_bytes([inode.block[2], inode.block[3]]);
assert_eq!(entries, 1, "journal should map as one contiguous extent");
}
}