feat(hermit-image-reader): Add tar bytes wrappers

Author: fogti

hermit-image-reader/examples/hermit-image-info.rs

@@ -4,7 +4,7 @@ fn main() {
 		let data = std::fs::read(f).expect("unable to read image file");
 		let decompressed = hermit_image_reader::decompress_image(&data[..])
 			.expect("unable to decompress image file");
-		for i in hermit_image_reader::ImageParser::new(&decompressed[..]) {
+		for i in hermit_image_reader::ImageParser::new(&decompressed) {
 			let i = i.expect("unable to read image entry");
 			print!("  Entry ");
 			let maybe_name = i.name.try_as_str();

hermit-image-reader/src/lib.rs

@@ -2,20 +2,19 @@
 
 extern crate alloc;
 
-use alloc::vec::Vec;
-
 /// We assume that all images are gzip-compressed
-pub fn decompress_image(data: &[u8]) -> Result<Vec<u8>, compression::prelude::CompressionError> {
+pub fn decompress_image(data: &[u8]) -> Result<TarBytes, compression::prelude::CompressionError> {
 	use compression::prelude::{DecodeExt as _, GZipDecoder};
 
 	data.iter()
 		.copied()
 		.decode(&mut GZipDecoder::new())
-		.collect()
+		.collect::<Result<_, _>>()
+		.map(TarBytes)
 }
 
 mod tar_parser;
-pub use tar_parser::{ImageFile, ImageParser, ImageParserError};
+pub use tar_parser::{ImageFile, ImageParser, ImageParserError, TarBytes, TarBytesSlice};
 
 pub mod config;
 

hermit-image-reader/src/tar_parser.rs

@@ -1,17 +1,17 @@
-use alloc::vec::Vec;
-use core::ops::Range;
+use alloc::{boxed::Box, vec::Vec};
+use core::ops::{Deref, Range};
 
 use crate::filename::{Filename, truncate};
 
 /// A parser for an already decompressed image
 #[derive(Clone, Copy)]
 pub struct ImageParser<'a> {
-	input: &'a [u8],
+	input: &'a TarBytesSlice,
 	offset: usize,
 }
 
 impl<'a> ImageParser<'a> {
-	pub fn new(input: &'a [u8]) -> Self {
+	pub fn new(input: &'a TarBytesSlice) -> Self {
 		Self { input, offset: 0 }
 	}
 }
@@ -56,6 +56,35 @@ impl<'a> From<core::str::Utf8Error> for ImageParserError<'a> {
 	}
 }
 
+/// Owned bytes belonging to a decompressed tar file
+#[derive(Clone, Default, PartialEq, Eq)]
+pub struct TarBytes(pub Box<[u8]>);
+
+#[derive(PartialEq, Eq)]
+#[repr(transparent)]
+pub struct TarBytesSlice(pub [u8]);
+
+impl Deref for TarBytes {
+	type Target = TarBytesSlice;
+
+	#[inline(always)]
+	fn deref(&self) -> &TarBytesSlice {
+		TarBytesSlice::new(&self.0[..])
+	}
+}
+
+impl TarBytesSlice {
+	#[inline(always)]
+	pub const fn new(data: &[u8]) -> &Self {
+		unsafe { &*(data as *const [u8] as *const Self) }
+	}
+
+	pub const fn split_at(&self, mid: usize) -> (&Self, &Self) {
+		let (a, b) = self.0.split_at(mid);
+		(Self::new(a), Self::new(b))
+	}
+}
+
 fn try_parse_octal<'a, T: num_traits::Num>(s: &[u8]) -> Result<T, ImageParserError<'a>>
 where
 	T::FromStrRadixErr: Into<ImageParserError<'a>>,
@@ -68,38 +97,38 @@ const BLOCK_SIZE_2POW: u32 = 9;
 
 impl<'a> ImageParser<'a> {
 	fn next_intern(&mut self) -> Result<Option<ImageFile<'a>>, ImageParserError<'a>> {
-		while self.input.len() >= BLOCK_SIZE {
+		while self.input.0.len() >= BLOCK_SIZE {
 			// `input` starts with a tar header, padded to 512 bytes (block size)
 			let offset = self.offset;
 			let (header, rest) = self.input.split_at(BLOCK_SIZE);
 
 			// note that integers are usually encoded as octal numbers
-			let name = truncate(&header[0..100]);
-			if header.iter().take_while(|i| **i == 0).count() == BLOCK_SIZE {
+			let name = truncate(&header.0[0..100]);
+			if header.0.iter().take_while(|i| **i == 0).count() == BLOCK_SIZE {
 				// EOF marker
 				return Ok(None);
 			}
-			let is_exec = if let Ok(mode) = try_parse_octal::<u16>(&header[100..108]) {
+			let is_exec = if let Ok(mode) = try_parse_octal::<u16>(&header.0[100..108]) {
 				mode & 0o111 != 0
 			} else {
 				false
 			};
-			let size: usize = try_parse_octal::<u64>(&header[124..136])?.try_into()?;
-			let _linkname = &header[157..257];
-			let magic = &header[257..263];
-			let _version = &header[263..265];
-			let prefix = &header[345..500];
+			let size: usize = try_parse_octal::<u64>(&header.0[124..136])?.try_into()?;
+			let _linkname = &header.0[157..257];
+			let magic = &header.0[257..263];
+			let _version = &header.0[263..265];
+			let prefix = &header.0[345..500];
 
 			// check if this is a supported file type
-			let ret = match header[156] {
+			let ret = match header.0[156] {
 				0 | b'0' => {
 					// regular file
 					let value_offset = offset + BLOCK_SIZE;
 					Some(ImageFile {
 						name: Filename::One(name),
 						is_exec,
 						value_range: value_offset..(value_offset + size),
-						value: rest.get(..size).ok_or(ImageParserError::UnexpectedEof)?,
+						value: rest.0.get(..size).ok_or(ImageParserError::UnexpectedEof)?,
 					})
 				}
 				_ => None,
@@ -117,9 +146,11 @@ impl<'a> ImageParser<'a> {
 				tmp << BLOCK_SIZE_2POW
 			};
 			self.offset += actual_rest_size;
-			self.input = rest
-				.get(actual_rest_size..)
-				.ok_or(ImageParserError::UnexpectedEof)?;
+			self.input = TarBytesSlice::new(
+				rest.0
+					.get(actual_rest_size..)
+					.ok_or(ImageParserError::UnexpectedEof)?,
+			);
 
 			if let Some(mut x) = ret {
 				// gather full file name (we might have to honor the ustar prefix)
@@ -133,7 +164,7 @@ impl<'a> ImageParser<'a> {
 			}
 		}
 
-		if self.input.is_empty() {
+		if self.input.0.is_empty() {
 			return Ok(None);
 		}
 		Err(ImageParserError::UnexpectedEof)
@@ -149,7 +180,7 @@ impl<'a> Iterator for ImageParser<'a> {
 			Ok(Some(x)) => Some(Ok(x)),
 			Err(e) => {
 				// make sure we don't get stuck
-				self.input = &[];
+				self.input = TarBytesSlice::new(&[]);
 				Some(Err(e))
 			}
 		}
@@ -165,7 +196,7 @@ mod tests {
 	proptest! {
 		#[test]
 		fn doesnt_crash(data: Vec<u8>) {
-			ImageParser::new(&*data).count();
+			ImageParser::new(TarBytesSlice::new(&*data)).count();
 		}
 	}
 }

hermit-image-reader/src/thin_tree.rs

@@ -1,6 +1,6 @@
 use alloc::collections::btree_map::BTreeMap;
 
-use crate::{ImageParser, ImageParserError, StrFilename};
+use crate::{ImageParser, ImageParserError, StrFilename, TarBytesSlice};
 
 #[derive(Clone, Debug, PartialEq, Eq, yoke::Yokeable)]
 pub enum ThinTreeRef<'a> {
@@ -39,7 +39,7 @@ impl<'a> ThinTreeRef<'a> {
 		Ok(())
 	}
 
-	pub fn try_from_image(image: &'a [u8]) -> Result<Self, ImageParserError<'a>> {
+	pub fn try_from_image(image: &'a TarBytesSlice) -> Result<Self, ImageParserError<'a>> {
 		let mut content = Self::File(b"");
 		for i in ImageParser::new(image) {
 			let i = i?;

src/isolation/image.rs

@@ -1,5 +1,6 @@
 use std::{
 	collections::HashMap,
+	fmt,
 	fs::canonicalize,
 	path::{Path, PathBuf},
 	sync::Arc,
@@ -9,14 +10,23 @@ pub use hermit_image_reader::thin_tree::ThinTreeRef as HermitImageThinTree;
 use yoke::Yoke;
 
 /// A "mounted" hermit image, the decompressed contents of it are mmap'ed into this process
-pub type HermitImage = Box<[u8]>;
+pub type HermitImage = hermit_image_reader::TarBytes;
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub enum MappedFile {
 	OnHost(PathBuf),
 	InImage(Yoke<HermitImageThinTree<'static>, Arc<HermitImage>>),
 }
 
+impl fmt::Debug for MappedFile {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			MappedFile::OnHost(oh) => write!(f, "OnHost({:?})", oh),
+			MappedFile::InImage(_) => write!(f, "InImage(..)"),
+		}
+	}
+}
+
 impl MappedFile {
 	#[cfg(test)]
 	pub(super) fn unwrap_on_host(self) -> PathBuf {
@@ -26,9 +36,7 @@ impl MappedFile {
 			panic!("unexpected mapped file: {:?}", self)
 		}
 	}
-}
 
-impl MappedFile {
 	pub fn resolve(&self, entry: &Path) -> Option<Self> {
 		match self {
 			MappedFile::OnHost(host_path) => {
@@ -83,10 +91,10 @@ impl Cache {
 						)
 					});
 
-				let image: Arc<Box<[u8]>> = Arc::new(decompressed.into());
+				let image: Arc<HermitImage> = Arc::new(decompressed);
 
 				Yoke::attach_to_cart(image, |image| {
-					HermitImageThinTree::try_from_image(&image[..]).unwrap_or_else(|e| {
+					HermitImageThinTree::try_from_image(image).unwrap_or_else(|e| {
 						panic!(
 							"{}: unable to parse hermit image file entry: {:?}",
 							host_path.display(),