src/image.rs: rename to tree.rs

This file has always had a bad name.  Conceptually it represents the
content of an image, but the word "image" has way too many meanings in
this crate.  When I talk to other people about this code I usually find
myself calling it "the in-memory filesystem tree", so let's rename it to
"tree".

This commit was completely automated thanks to LSP tooling and rust-fmt.

Signed-off-by: Allison Karlitskaya <[email protected]>

Author: allisonkarlitskaya

src/dumpfile.rs

@@ -13,7 +13,7 @@ use rustix::fs::FileType;
 
 use crate::{
     fsverity::FsVerityHashValue,
-    image::{Directory, FileSystem, Inode, Leaf, LeafContent, RegularFile, Stat},
+    tree::{Directory, FileSystem, Inode, Leaf, LeafContent, RegularFile, Stat},
 };
 
 fn write_empty(writer: &mut impl fmt::Write) -> fmt::Result {

src/erofs/writer.rs

@@ -13,7 +13,7 @@ use zerocopy::{Immutable, IntoBytes};
 use crate::{
     erofs::{composefs::OverlayMetacopy, format, reader::round_up},
     fsverity::FsVerityHashValue,
-    image,
+    tree,
 };
 
 #[derive(Clone, Copy, Debug)]
@@ -83,7 +83,7 @@ struct Directory<'a> {
 
 #[derive(Debug)]
 struct Leaf<'a, ObjectID: FsVerityHashValue> {
-    content: &'a image::LeafContent<ObjectID>,
+    content: &'a tree::LeafContent<ObjectID>,
     nlink: usize,
 }
 
@@ -94,7 +94,7 @@ enum InodeContent<'a, ObjectID: FsVerityHashValue> {
 }
 
 struct Inode<'a, ObjectID: FsVerityHashValue> {
-    stat: &'a image::Stat,
+    stat: &'a tree::Stat,
     xattrs: InodeXAttrs,
     content: InodeContent<'a, ObjectID>,
 }
@@ -266,23 +266,23 @@ impl<'a> Directory<'a> {
 impl<ObjectID: FsVerityHashValue> Leaf<'_, ObjectID> {
     fn inode_meta(&self) -> (format::DataLayout, u32, u64, usize) {
         let (layout, u, size) = match &self.content {
-            image::LeafContent::Regular(image::RegularFile::Inline(data)) => {
+            tree::LeafContent::Regular(tree::RegularFile::Inline(data)) => {
                 if data.is_empty() {
                     (format::DataLayout::FlatPlain, 0, data.len() as u64)
                 } else {
                     (format::DataLayout::FlatInline, 0, data.len() as u64)
                 }
             }
-            image::LeafContent::Regular(image::RegularFile::External(.., size)) => {
+            tree::LeafContent::Regular(tree::RegularFile::External(.., size)) => {
                 (format::DataLayout::ChunkBased, 31, *size)
             }
-            image::LeafContent::CharacterDevice(rdev) | image::LeafContent::BlockDevice(rdev) => {
+            tree::LeafContent::CharacterDevice(rdev) | tree::LeafContent::BlockDevice(rdev) => {
                 (format::DataLayout::FlatPlain, *rdev as u32, 0)
             }
-            image::LeafContent::Fifo | image::LeafContent::Socket => {
+            tree::LeafContent::Fifo | tree::LeafContent::Socket => {
                 (format::DataLayout::FlatPlain, 0, 0)
             }
-            image::LeafContent::Symlink(target) => {
+            tree::LeafContent::Symlink(target) => {
                 (format::DataLayout::FlatInline, 0, target.len() as u64)
             }
         };
@@ -291,9 +291,9 @@ impl<ObjectID: FsVerityHashValue> Leaf<'_, ObjectID> {
 
     fn write_inline(&self, output: &mut impl Output) {
         output.write(match self.content {
-            image::LeafContent::Regular(image::RegularFile::Inline(data)) => data,
-            image::LeafContent::Regular(image::RegularFile::External(..)) => b"\xff\xff\xff\xff", // null chunk
-            image::LeafContent::Symlink(target) => target.as_bytes(),
+            tree::LeafContent::Regular(tree::RegularFile::Inline(data)) => data,
+            tree::LeafContent::Regular(tree::RegularFile::External(..)) => b"\xff\xff\xff\xff", // null chunk
+            tree::LeafContent::Symlink(target) => target.as_bytes(),
             _ => &[],
         });
     }
@@ -304,12 +304,12 @@ impl<ObjectID: FsVerityHashValue> Inode<'_, ObjectID> {
         match &self.content {
             InodeContent::Directory(..) => format::FileType::Directory,
             InodeContent::Leaf(leaf) => match &leaf.content {
-                image::LeafContent::Regular(..) => format::FileType::RegularFile,
-                image::LeafContent::CharacterDevice(..) => format::FileType::CharacterDevice,
-                image::LeafContent::BlockDevice(..) => format::FileType::BlockDevice,
-                image::LeafContent::Fifo => format::FileType::Fifo,
-                image::LeafContent::Socket => format::FileType::Socket,
-                image::LeafContent::Symlink(..) => format::FileType::Symlink,
+                tree::LeafContent::Regular(..) => format::FileType::RegularFile,
+                tree::LeafContent::CharacterDevice(..) => format::FileType::CharacterDevice,
+                tree::LeafContent::BlockDevice(..) => format::FileType::BlockDevice,
+                tree::LeafContent::Fifo => format::FileType::Fifo,
+                tree::LeafContent::Socket => format::FileType::Socket,
+                tree::LeafContent::Symlink(..) => format::FileType::Symlink,
             },
         }
     }
@@ -397,16 +397,16 @@ impl<ObjectID: FsVerityHashValue> Inode<'_, ObjectID> {
 
 struct InodeCollector<'a, ObjectID: FsVerityHashValue> {
     inodes: Vec<Inode<'a, ObjectID>>,
-    hardlinks: HashMap<*const image::Leaf<ObjectID>, usize>,
+    hardlinks: HashMap<*const tree::Leaf<ObjectID>, usize>,
 }
 
 impl<'a, ObjectID: FsVerityHashValue> InodeCollector<'a, ObjectID> {
-    fn push_inode(&mut self, stat: &'a image::Stat, content: InodeContent<'a, ObjectID>) -> usize {
+    fn push_inode(&mut self, stat: &'a tree::Stat, content: InodeContent<'a, ObjectID>) -> usize {
         let mut xattrs = InodeXAttrs::default();
 
         // We need to record extra xattrs for some files.  These come first.
         if let InodeContent::Leaf(Leaf {
-            content: image::LeafContent::Regular(image::RegularFile::External(id, ..)),
+            content: tree::LeafContent::Regular(tree::RegularFile::External(id, ..)),
             ..
         }) = content
         {
@@ -442,7 +442,7 @@ impl<'a, ObjectID: FsVerityHashValue> InodeCollector<'a, ObjectID> {
         inode
     }
 
-    fn collect_leaf(&mut self, leaf: &'a Rc<image::Leaf<ObjectID>>) -> usize {
+    fn collect_leaf(&mut self, leaf: &'a Rc<tree::Leaf<ObjectID>>) -> usize {
         let nlink = Rc::strong_count(leaf);
 
         if nlink > 1 {
@@ -481,7 +481,7 @@ impl<'a, ObjectID: FsVerityHashValue> InodeCollector<'a, ObjectID> {
         entries.insert(point, entry);
     }
 
-    fn collect_dir(&mut self, dir: &'a image::Directory<ObjectID>, parent: usize) -> usize {
+    fn collect_dir(&mut self, dir: &'a tree::Directory<ObjectID>, parent: usize) -> usize {
         // The root inode number needs to fit in a u16.  That more or less compels us to write the
         // directory inode before the inode of the children of the directory.  Reserve a slot.
         let me = self.push_inode(&dir.stat, InodeContent::Directory(Directory::default()));
@@ -490,8 +490,8 @@ impl<'a, ObjectID: FsVerityHashValue> InodeCollector<'a, ObjectID> {
 
         for (name, inode) in dir.sorted_entries() {
             let child = match inode {
-                image::Inode::Directory(dir) => self.collect_dir(dir, me),
-                image::Inode::Leaf(leaf) => self.collect_leaf(leaf),
+                tree::Inode::Directory(dir) => self.collect_dir(dir, me),
+                tree::Inode::Leaf(leaf) => self.collect_leaf(leaf),
             };
             entries.push(DirEnt {
                 name: name.as_bytes(),
@@ -509,7 +509,7 @@ impl<'a, ObjectID: FsVerityHashValue> InodeCollector<'a, ObjectID> {
         me
     }
 
-    pub fn collect(fs: &'a image::FileSystem<ObjectID>) -> Vec<Inode<'a, ObjectID>> {
+    pub fn collect(fs: &'a tree::FileSystem<ObjectID>) -> Vec<Inode<'a, ObjectID>> {
         let mut this = Self {
             inodes: vec![],
             hardlinks: HashMap::new(),
@@ -688,7 +688,7 @@ impl Output for FirstPass {
     }
 }
 
-pub fn mkfs_erofs<ObjectID: FsVerityHashValue>(fs: &image::FileSystem<ObjectID>) -> Box<[u8]> {
+pub fn mkfs_erofs<ObjectID: FsVerityHashValue>(fs: &tree::FileSystem<ObjectID>) -> Box<[u8]> {
     // Create the intermediate representation: flattened inodes and shared xattrs
     let mut inodes = InodeCollector::collect(fs);
     let xattrs = share_xattrs(&mut inodes);

src/fs.rs

@@ -25,9 +25,9 @@ use zerocopy::IntoBytes;
 
 use crate::{
     fsverity::{compute_verity, FsVerityHashValue},
-    image::{Directory, FileSystem, Inode, Leaf, LeafContent, RegularFile, Stat},
     repository::Repository,
     selabel::selabel,
+    tree::{Directory, FileSystem, Inode, Leaf, LeafContent, RegularFile, Stat},
     util::proc_self_fd,
     INLINE_CONTENT_MAX,
 };

src/lib.rs

@@ -5,13 +5,13 @@ pub mod dumpfile_parse;
 pub mod erofs;
 pub mod fs;
 pub mod fsverity;
-pub mod image;
 pub mod mount;
 pub mod mountcompat;
 pub mod oci;
 pub mod repository;
 pub mod selabel;
 pub mod splitstream;
+pub mod tree;
 pub mod uki;
 pub mod util;
 

src/oci/image.rs

@@ -7,13 +7,13 @@ use crate::{
     dumpfile::write_dumpfile,
     erofs::writer::mkfs_erofs,
     fsverity::FsVerityHashValue,
-    image::{Directory, FileSystem, Inode, Leaf},
     oci::{
         self,
         tar::{TarEntry, TarItem},
     },
     repository::Repository,
     selabel::selabel,
+    tree::{Directory, FileSystem, Inode, Leaf},
 };
 
 pub fn process_entry<ObjectID: FsVerityHashValue>(
@@ -107,7 +107,7 @@ pub fn create_image<ObjectID: FsVerityHashValue>(
 mod test {
     use crate::{
         fsverity::Sha256HashValue,
-        image::{LeafContent, RegularFile, Stat},
+        tree::{LeafContent, RegularFile, Stat},
     };
     use std::{cell::RefCell, collections::BTreeMap, io::BufRead, path::PathBuf};
 

src/oci/mod.rs

@@ -391,7 +391,7 @@ pub fn prepare_boot<ObjectID: FsVerityHashValue>(
         .with_context(|| "Attachments layer {layer} is not connected to image {name}")?;
 
     // read the layer into a FileSystem object
-    let mut filesystem = crate::image::FileSystem::new();
+    let mut filesystem = crate::tree::FileSystem::new();
     let mut split_stream = repo.open_stream(&hex::encode(layer_sha256), Some(layer_verity))?;
     while let Some(entry) = tar::get_entry(&mut split_stream)? {
         image::process_entry(&mut filesystem, entry)?;

src/oci/tar.rs

@@ -16,8 +16,8 @@ use tokio::io::{AsyncRead, AsyncReadExt};
 use crate::{
     dumpfile,
     fsverity::FsVerityHashValue,
-    image::{LeafContent, RegularFile, Stat},
     splitstream::{SplitStreamData, SplitStreamReader, SplitStreamWriter},
+    tree::{LeafContent, RegularFile, Stat},
     util::{read_exactish, read_exactish_async},
     INLINE_CONTENT_MAX,
 };

src/selabel.rs

@@ -12,8 +12,8 @@ use regex_automata::{hybrid::dfa, util::syntax, Anchored, Input};
 
 use crate::{
     fsverity::FsVerityHashValue,
-    image::{Directory, FileSystem, ImageError, Inode, Leaf, LeafContent, RegularFile, Stat},
     repository::Repository,
+    tree::{Directory, FileSystem, ImageError, Inode, Leaf, LeafContent, RegularFile, Stat},
 };
 
 /* We build the entire SELinux policy into a single "lazy DFA" such that:

src/image.rs renamed to src/tree.rs

@@ -96,7 +96,7 @@ impl<ObjectID: FsVerityHashValue> Directory<ObjectID> {
     /// point.
     ///
     /// ```
-    /// use composefs::{image::FileSystem, fsverity::Sha256HashValue};
+    /// use composefs::{tree::FileSystem, fsverity::Sha256HashValue};
     /// let fs = FileSystem::<Sha256HashValue>::new();
     ///
     /// // populate the fs...

tests/mkfs.rs

@@ -14,7 +14,7 @@ use composefs::{
     dumpfile::write_dumpfile,
     erofs::{debug::debug_img, writer::mkfs_erofs},
     fsverity::{FsVerityHashValue, Sha256HashValue},
-    image::{Directory, FileSystem, Inode, Leaf, LeafContent, RegularFile, Stat},
+    tree::{Directory, FileSystem, Inode, Leaf, LeafContent, RegularFile, Stat},
 };
 
 fn debug_fs(mut fs: FileSystem<impl FsVerityHashValue>) -> String {