src: make everything generic over FsVerityHashValue

Convert all of the many places that we've been using Sha256HashValue for
fs-verity hashes to be generic over FsVerityHashValue instead.  Work the
changes out across the codebase.

Due to some missing features in Rust, this change (while fairly
mechnical) is also pretty large.  See for example:
 - it's not possible to omit type parameters from the declaration of a
   function when they are irrelevant to the body of the function
 - rust-lang/rfcs#424

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

Author: allisonkarlitskaya

src/bin/cfsctl.rs

@@ -111,7 +111,7 @@ fn main() -> Result<()> {
 
     let args = App::parse();
 
-    let repo = (if let Some(path) = args.repo {
+    let repo: Repository<Sha256HashValue> = (if let Some(path) = args.repo {
         Repository::open_path(CWD, path)
     } else if args.system {
         Repository::open_system()
@@ -193,7 +193,7 @@ fn main() -> Result<()> {
             println!("{}", image_id.to_hex());
         }
         Command::CreateDumpfile { ref path } => {
-            composefs::fs::create_dumpfile(path)?;
+            composefs::fs::create_dumpfile::<Sha256HashValue>(path)?;
         }
         Command::Mount { name, mountpoint } => {
             repo.mount(&name, &mountpoint)?;

src/bin/composefs-setup-root.rs

@@ -167,7 +167,7 @@ fn open_root_fs(path: &Path) -> Result<OwnedFd> {
 }
 
 fn mount_composefs_image(sysroot: &OwnedFd, name: &str) -> Result<OwnedFd> {
-    let repo = Repository::open_path(sysroot, "composefs")?;
+    let repo = Repository::<Sha256HashValue>::open_path(sysroot, "composefs")?;
     let image = repo.open_image(name)?;
     composefs_fsmount(image, name, repo.object_dir()?).context("Failed to mount composefs image")
 }
@@ -200,11 +200,11 @@ fn mount_subdir(
 }
 
 // Implementation
-fn parse_composefs_cmdline(cmdline: &[u8]) -> Result<Sha256HashValue> {
+fn parse_composefs_cmdline<H: FsVerityHashValue>(cmdline: &[u8]) -> Result<H> {
     // TODO?: officially we need to understand quoting with double-quotes...
     for part in cmdline.split(|c| c.is_ascii_whitespace()) {
         if let Some(digest) = part.strip_prefix(b"composefs=") {
-            return Sha256HashValue::from_hex(digest).context("Parsing composefs=");
+            return H::from_hex(digest).context("Parsing composefs=");
         }
     }
     bail!("Unable to find composefs= cmdline parameter");
@@ -236,7 +236,7 @@ fn setup_root(args: Args) -> Result<()> {
         Some(cmdline) => cmdline.as_bytes(),
         None => &std::fs::read("/proc/cmdline")?,
     };
-    let image = parse_composefs_cmdline(cmdline)?.to_hex();
+    let image = parse_composefs_cmdline::<Sha256HashValue>(cmdline)?.to_hex();
 
     let new_root = match args.root_fs {
         Some(path) => open_root_fs(&path).context("Failed to clone specified root fs")?,
@@ -290,11 +290,12 @@ mod test {
     fn test_parse() {
         let failing = ["", "foo", "composefs", "composefs=foo"];
         for case in failing {
-            assert!(parse_composefs_cmdline(case.as_bytes()).is_err());
+            assert!(parse_composefs_cmdline::<Sha256HashValue>(case.as_bytes()).is_err());
         }
         let digest = "8b7df143d91c716ecfa5fc1730022f6b421b05cedee8fd52b1fc65a96030ad52";
         similar_asserts::assert_eq!(
-            parse_composefs_cmdline(format!("composefs={digest}").as_bytes()).unwrap(),
+            parse_composefs_cmdline::<Sha256HashValue>(format!("composefs={digest}").as_bytes())
+                .unwrap(),
             Sha256HashValue::from_hex(digest).unwrap()
         );
     }

src/dumpfile.rs

@@ -101,11 +101,11 @@ pub fn write_directory(
     )
 }
 
-pub fn write_leaf(
+pub fn write_leaf<ObjectID: FsVerityHashValue>(
     writer: &mut impl fmt::Write,
     path: &Path,
     stat: &Stat,
-    content: &LeafContent,
+    content: &LeafContent<ObjectID>,
     nlink: usize,
 ) -> fmt::Result {
     match content {
@@ -204,8 +204,8 @@ pub fn write_hardlink(writer: &mut impl fmt::Write, path: &Path, target: &OsStr)
     Ok(())
 }
 
-struct DumpfileWriter<'a, W: Write> {
-    hardlinks: HashMap<*const Leaf, OsString>,
+struct DumpfileWriter<'a, W: Write, ObjectID: FsVerityHashValue> {
+    hardlinks: HashMap<*const Leaf<ObjectID>, OsString>,
     writer: &'a mut W,
 }
 
@@ -215,15 +215,15 @@ fn writeln_fmt(writer: &mut impl Write, f: impl Fn(&mut String) -> fmt::Result)
     Ok(writeln!(writer, "{}", tmp)?)
 }
 
-impl<'a, W: Write> DumpfileWriter<'a, W> {
+impl<'a, W: Write, ObjectID: FsVerityHashValue> DumpfileWriter<'a, W, ObjectID> {
     fn new(writer: &'a mut W) -> Self {
         Self {
             hardlinks: HashMap::new(),
             writer,
         }
     }
 
-    fn write_dir(&mut self, path: &mut PathBuf, dir: &Directory) -> Result<()> {
+    fn write_dir(&mut self, path: &mut PathBuf, dir: &Directory<ObjectID>) -> Result<()> {
         // nlink is 2 + number of subdirectories
         // this is also true for the root dir since '..' is another self-ref
         let nlink = dir.inodes().fold(2, |count, inode| {
@@ -256,7 +256,7 @@ impl<'a, W: Write> DumpfileWriter<'a, W> {
         Ok(())
     }
 
-    fn write_leaf(&mut self, path: &Path, leaf: &Rc<Leaf>) -> Result<()> {
+    fn write_leaf(&mut self, path: &Path, leaf: &Rc<Leaf<ObjectID>>) -> Result<()> {
         let nlink = Rc::strong_count(leaf);
 
         if nlink > 1 {
@@ -276,7 +276,10 @@ impl<'a, W: Write> DumpfileWriter<'a, W> {
     }
 }
 
-pub fn write_dumpfile<W: Write>(writer: &mut W, fs: &FileSystem) -> Result<()> {
+pub fn write_dumpfile(
+    writer: &mut impl Write,
+    fs: &FileSystem<impl FsVerityHashValue>,
+) -> Result<()> {
     // default pipe capacity on Linux is 16 pages (65536 bytes), but
     // sometimes the BufWriter will write more than its capacity...
     let mut buffer = BufWriter::with_capacity(32768, writer);

src/erofs/reader.rs

@@ -12,7 +12,7 @@ use super::{
         InodeXAttrHeader, ModeField, Superblock, XAttrHeader,
     },
 };
-use crate::fsverity::Sha256HashValue;
+use crate::fsverity::FsVerityHashValue;
 
 pub fn round_up(n: usize, to: usize) -> usize {
     (n + to - 1) & !(to - 1)
@@ -486,13 +486,13 @@ pub enum ErofsReaderError {
 type ReadResult<T> = Result<T, ErofsReaderError>;
 
 #[derive(Debug)]
-pub struct ObjectCollector {
+pub struct ObjectCollector<ObjectID: FsVerityHashValue> {
     visited_nids: HashSet<u64>,
     nids_to_visit: BTreeSet<u64>,
-    objects: HashSet<Sha256HashValue>,
+    objects: HashSet<ObjectID>,
 }
 
-impl ObjectCollector {
+impl<ObjectID: FsVerityHashValue> ObjectCollector<ObjectID> {
     fn visit_xattr(&mut self, attr: &XAttr) {
         // This is the index of "trusted".  See XATTR_PREFIXES in format.rs.
         if attr.header.name_index != 4 {
@@ -552,7 +552,7 @@ impl ObjectCollector {
     }
 }
 
-pub fn collect_objects(image: &[u8]) -> ReadResult<HashSet<Sha256HashValue>> {
+pub fn collect_objects<ObjectID: FsVerityHashValue>(image: &[u8]) -> ReadResult<HashSet<ObjectID>> {
     let img = Image::open(image);
     let mut this = ObjectCollector {
         visited_nids: HashSet::new(),

src/erofs/writer.rs

@@ -82,21 +82,21 @@ struct Directory<'a> {
 }
 
 #[derive(Debug)]
-struct Leaf<'a> {
-    content: &'a image::LeafContent,
+struct Leaf<'a, ObjectID: FsVerityHashValue> {
+    content: &'a image::LeafContent<ObjectID>,
     nlink: usize,
 }
 
 #[derive(Debug)]
-enum InodeContent<'a> {
+enum InodeContent<'a, ObjectID: FsVerityHashValue> {
     Directory(Directory<'a>),
-    Leaf(Leaf<'a>),
+    Leaf(Leaf<'a, ObjectID>),
 }
 
-struct Inode<'a> {
+struct Inode<'a, ObjectID: FsVerityHashValue> {
     stat: &'a image::Stat,
     xattrs: InodeXAttrs,
-    content: InodeContent<'a>,
+    content: InodeContent<'a, ObjectID>,
 }
 
 impl XAttr {
@@ -263,7 +263,7 @@ impl<'a> Directory<'a> {
     }
 }
 
-impl Leaf<'_> {
+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)) => {
@@ -299,7 +299,7 @@ impl Leaf<'_> {
     }
 }
 
-impl Inode<'_> {
+impl<ObjectID: FsVerityHashValue> Inode<'_, ObjectID> {
     fn file_type(&self) -> format::FileType {
         match &self.content {
             InodeContent::Directory(..) => format::FileType::Directory,
@@ -395,13 +395,13 @@ impl Inode<'_> {
     }
 }
 
-struct InodeCollector<'a> {
-    inodes: Vec<Inode<'a>>,
-    hardlinks: HashMap<*const image::Leaf, usize>,
+struct InodeCollector<'a, ObjectID: FsVerityHashValue> {
+    inodes: Vec<Inode<'a, ObjectID>>,
+    hardlinks: HashMap<*const image::Leaf<ObjectID>, usize>,
 }
 
-impl<'a> InodeCollector<'a> {
-    fn push_inode(&mut self, stat: &'a image::Stat, content: InodeContent<'a>) -> usize {
+impl<'a, ObjectID: FsVerityHashValue> InodeCollector<'a, ObjectID> {
+    fn push_inode(&mut self, stat: &'a image::Stat, content: InodeContent<'a, ObjectID>) -> usize {
         let mut xattrs = InodeXAttrs::default();
 
         // We need to record extra xattrs for some files.  These come first.
@@ -442,7 +442,7 @@ impl<'a> InodeCollector<'a> {
         inode
     }
 
-    fn collect_leaf(&mut self, leaf: &'a Rc<image::Leaf>) -> usize {
+    fn collect_leaf(&mut self, leaf: &'a Rc<image::Leaf<ObjectID>>) -> usize {
         let nlink = Rc::strong_count(leaf);
 
         if nlink > 1 {
@@ -481,7 +481,7 @@ impl<'a> InodeCollector<'a> {
         entries.insert(point, entry);
     }
 
-    fn collect_dir(&mut self, dir: &'a image::Directory, parent: usize) -> usize {
+    fn collect_dir(&mut self, dir: &'a image::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()));
@@ -509,7 +509,7 @@ impl<'a> InodeCollector<'a> {
         me
     }
 
-    pub fn collect(fs: &'a image::FileSystem) -> Vec<Inode<'a>> {
+    pub fn collect(fs: &'a image::FileSystem<ObjectID>) -> Vec<Inode<'a, ObjectID>> {
         let mut this = Self {
             inodes: vec![],
             hardlinks: HashMap::new(),
@@ -525,7 +525,7 @@ impl<'a> InodeCollector<'a> {
 
 /// Takes a list of inodes where each inode contains only local xattr values, determines which
 /// xattrs (key, value) pairs appear more than once, and shares them.
-fn share_xattrs(inodes: &mut [Inode]) -> Vec<XAttr> {
+fn share_xattrs<ObjectID: FsVerityHashValue>(inodes: &mut [Inode<ObjectID>]) -> Vec<XAttr> {
     let mut xattrs: BTreeMap<XAttr, usize> = BTreeMap::new();
 
     // Collect all xattrs from the inodes
@@ -563,7 +563,11 @@ fn share_xattrs(inodes: &mut [Inode]) -> Vec<XAttr> {
     xattrs.into_keys().collect()
 }
 
-fn write_erofs(output: &mut impl Output, inodes: &[Inode], xattrs: &[XAttr]) {
+fn write_erofs<ObjectID: FsVerityHashValue>(
+    output: &mut impl Output,
+    inodes: &[Inode<ObjectID>],
+    xattrs: &[XAttr],
+) {
     // Write composefs header
     output.note_offset(Offset::Header);
     output.write_struct(format::ComposefsHeader {
@@ -684,7 +688,7 @@ impl Output for FirstPass {
     }
 }
 
-pub fn mkfs_erofs(fs: &image::FileSystem) -> Box<[u8]> {
+pub fn mkfs_erofs<ObjectID: FsVerityHashValue>(fs: &image::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);