Split into library and binary parts and implement fuzzer

Makefile

@@ -32,6 +32,6 @@ clean:
 	cargo clean
 
 fuse-ufs-bin: Cargo.lock ${SRC}
-	cargo build --release
+	cargo build --release -p fuse-ufs
 	cp -f target/release/fuse-ufs fuse-ufs-bin
 

fuse-ufs/Cargo.toml

@@ -3,7 +3,7 @@ name = "fuse-ufs"
 version = "0.3.0"
 edition = "2021"
 license = "BSD-2-Clause"
-authors = ["Benjamin Stürz <benni@stuerz.xyz>", "Alan Somers <asomers@gmail.com>"]
+authors = ["Benjamin Stürz <benni@stuerz.xyz>", "Alan Somers <asomers@gmail.com>", "Davids Paskevics <davids.paskevics@gmail.com>"]
 description = "FUSE implementation of FreeBSD's UFSv2"
 repository = "https://github.com/realchonk/fuse-ufs"
 rust-version = "1.74.0"
@@ -19,7 +19,7 @@ env_logger.workspace = true
 fuser.workspace = true
 libc.workspace = true
 log.workspace = true
-rufs = { path = "../rufs" }
+rufs = { path = "../rufs", features = ["fuser"] }
 
 [dev-dependencies]
 assert_cmd.workspace = true

fuse-ufs/src/fs.rs

@@ -6,7 +6,7 @@ use std::{
 	time::Duration,
 };
 
-use fuser::{Filesystem, KernelConfig, Request};
+use fuser::{FileAttr, Filesystem, KernelConfig, Request};
 use rufs::{InodeNum, Ufs};
 
 const MAX_CACHE: Duration = Duration::MAX;
@@ -52,8 +52,8 @@ impl Filesystem for Fs {
 		// TODO: don't use read_inode()
 		let f = || {
 			let inr = transino(ino)?;
-			let ino = self.ufs.read_inode(inr)?;
-			Ok(ino.as_fileattr(inr))
+			let st: FileAttr = self.ufs.inode_attr(inr)?.into();
+			Ok(st)
 		};
 		match run(f) {
 			Ok(x) => reply.attr(&MAX_CACHE, &x),
@@ -90,7 +90,7 @@ impl Filesystem for Fs {
 
 			self.ufs.dir_iter(inr, |name, inr, kind| {
 				i += 1;
-				if i > offset && reply.add(inr.get64(), i, kind, name) {
+				if i > offset && reply.add(inr.get64(), i, kind.into(), name) {
 					return Some(());
 				}
 				None
@@ -108,12 +108,12 @@ impl Filesystem for Fs {
 		let mut f = || {
 			let pinr = transino(pinr)?;
 			let inr = self.ufs.dir_lookup(pinr, name)?;
-			let ino = self.ufs.read_inode(inr)?;
-			Ok::<_, IoError>((ino.as_fileattr(inr), ino.gen))
+			let st = self.ufs.inode_attr(inr)?;
+			Ok::<_, IoError>((st.gen, st.into()))
 		};
 
 		match f() {
-			Ok((attr, gen)) => reply.entry(&Duration::ZERO, &attr, gen.into()),
+			Ok((gen, st)) => reply.entry(&Duration::ZERO, &st, gen.into()),
 			Err(e) => {
 				if e.kind() != ErrorKind::NotFound {
 					log::error!("Error: {e}");

rufs/Cargo.toml

@@ -3,17 +3,20 @@ name = "rufs"
 version = "0.3.0"
 edition = "2021"
 license = "BSD-2-Clause"
-authors = ["Benjamin Stürz <benni@stuerz.xyz>", "Alan Somers <asomers@gmail.com>"]
+authors = ["Benjamin Stürz <benni@stuerz.xyz>", "Alan Somers <asomers@gmail.com>", "Davids Paskevics <davids.paskevics@gmail.com>"]
 description = "FUSE implementation of FreeBSD's UFSv2"
 repository = "https://github.com/realchonk/fuse-ufs"
 rust-version = "1.74.0"
 documentation = "https://docs.rs/rufs"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[features]
+fuser = ["dep:fuser"]
+
 [dependencies]
 bincode.workspace = true
-fuser.workspace = true
+fuser = { workspace = true, optional = true }
 libc.workspace = true
 log.workspace = true
 

rufs/src/data.rs

@@ -5,6 +5,7 @@ use std::{
 	ffi::{OsStr, OsString},
 	fmt::{self, Display, Formatter},
 	mem::size_of,
+	time::SystemTime,
 };
 
 use bincode::Decode;
@@ -356,6 +357,39 @@ pub struct Inode {
 	pub spare:     [u32; 2], // 248: Reserved; currently unused
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum InodeType {
+	RegularFile,
+	Directory,
+	Symlink,
+	CharDevice,
+	BlockDevice,
+	Socket,
+	NamedPipe,
+	//Whiteout,
+}
+
+#[derive(Debug)]
+pub struct InodeAttr {
+	pub inr:       InodeNum,
+	pub perm:      u16,
+	pub kind:      InodeType,
+	pub size:      u64,
+	pub blocks:    u64,
+	pub atime:     SystemTime,
+	pub mtime:     SystemTime,
+	pub ctime:     SystemTime,
+	pub btime:     SystemTime,
+	pub nlink:     u16,
+	pub uid:       u32,
+	pub gid:       u32,
+	pub gen:       u32,
+	pub blksize:   u32,
+	pub flags:     u32,
+	pub kernflags: u32,
+	pub extsize:   u32,
+}
+
 #[derive(Debug, Clone, Copy, Decode, PartialEq, Eq)]
 #[repr(u8)]
 pub enum ExtattrNamespace {

rufs/src/inode.rs

@@ -1,7 +1,6 @@
 use std::time::{Duration, SystemTime};
 
 use bincode::{de::Decoder, error::DecodeError, Decode};
-use fuser::{FileAttr, FileType};
 
 use crate::data::*;
 
@@ -41,44 +40,46 @@ impl Inode {
 		self.mode & 0o7777
 	}
 
-	pub fn kind(&self) -> FileType {
+	pub fn kind(&self) -> InodeType {
 		let mode = self.mode & S_IFMT;
 		match mode {
-			S_IFIFO => FileType::NamedPipe,
-			S_IFCHR => FileType::CharDevice,
-			S_IFDIR => FileType::Directory,
-			S_IFBLK => FileType::BlockDevice,
-			S_IFREG => FileType::RegularFile,
-			S_IFLNK => FileType::Symlink,
-			S_IFSOCK => FileType::Socket,
+			S_IFIFO => InodeType::NamedPipe,
+			S_IFCHR => InodeType::CharDevice,
+			S_IFDIR => InodeType::Directory,
+			S_IFBLK => InodeType::BlockDevice,
+			S_IFREG => InodeType::RegularFile,
+			S_IFLNK => InodeType::Symlink,
+			S_IFSOCK => InodeType::Socket,
 			_ => unreachable!("invalid file mode: {mode:o}"),
 		}
 	}
 
-	pub fn as_fileattr(&self, ino: InodeNum) -> FileAttr {
-		FileAttr {
-			ino:     ino.get64(),
-			size:    self.size,
-			blocks:  self.blocks,
-			atime:   self.atime(),
-			mtime:   self.mtime(),
-			ctime:   self.ctime(),
-			crtime:  self.btime(),
-			kind:    self.kind(),
-			perm:    self.perm(),
-			nlink:   self.nlink.into(),
-			uid:     self.uid,
-			gid:     self.gid,
-			rdev:    0,
+	pub fn as_attr(&self, inr: InodeNum) -> InodeAttr {
+		InodeAttr {
+			inr,
+			perm: self.mode & 0o7777,
+			kind: self.kind(),
+			size: self.size,
+			blocks: self.blocks,
+			atime: self.atime(),
+			mtime: self.mtime(),
+			ctime: self.ctime(),
+			btime: self.btime(),
+			nlink: self.nlink,
+			uid: self.uid,
+			gid: self.gid,
+			gen: self.gen,
 			blksize: self.blksize,
-			flags:   self.flags,
+			flags: self.flags,
+			kernflags: self.kernflags,
+			extsize: self.extsize,
 		}
 	}
 
 	pub fn size(&self, bs: u64, fs: u64) -> (u64, u64) {
 		let size = match self.kind() {
-			FileType::Directory => self.blocks * fs,
-			FileType::RegularFile | FileType::Symlink => self.size,
+			InodeType::Directory => self.blocks * fs,
+			InodeType::RegularFile | InodeType::Symlink => self.size,
 			kind => todo!("Inode::size() is undefined for {kind:?}"),
 		};
 		Self::inode_size(bs, fs, size)
@@ -169,3 +170,46 @@ mod test {
 		assert_eq!(isz(100 * bs + 7 * fs), (100, 7));
 	}
 }
+
+#[cfg(feature = "fuser")]
+mod f {
+	use fuser::{FileAttr, FileType};
+
+	use super::*;
+
+	impl From<InodeType> for FileType {
+		fn from(t: InodeType) -> Self {
+			match t {
+				InodeType::RegularFile => Self::RegularFile,
+				InodeType::Directory => Self::Directory,
+				InodeType::Symlink => Self::Symlink,
+				InodeType::Socket => Self::Socket,
+				InodeType::CharDevice => Self::CharDevice,
+				InodeType::BlockDevice => Self::BlockDevice,
+				InodeType::NamedPipe => Self::NamedPipe,
+			}
+		}
+	}
+
+	impl From<InodeAttr> for FileAttr {
+		fn from(a: InodeAttr) -> Self {
+			Self {
+				ino:     a.inr.get64(),
+				size:    a.size,
+				blocks:  a.blocks,
+				atime:   a.atime,
+				mtime:   a.mtime,
+				ctime:   a.ctime,
+				crtime:  a.atime,
+				kind:    a.kind.into(),
+				perm:    a.perm,
+				nlink:   a.nlink.into(),
+				uid:     a.uid,
+				gid:     a.gid,
+				rdev:    0,
+				blksize: a.blksize,
+				flags:   a.flags,
+			}
+		}
+	}
+}

rufs/src/ufs/dir.rs

@@ -5,7 +5,7 @@ fn readdir_block<T>(
 	inr: InodeNum,
 	block: &[u8],
 	config: Config,
-	mut f: impl FnMut(&OsStr, InodeNum, FileType) -> Option<T>,
+	mut f: impl FnMut(&OsStr, InodeNum, InodeType) -> Option<T>,
 ) -> IoResult<Option<T>> {
 	let mut name = [0u8; UFS_MAXNAMELEN + 1];
 	let file = Cursor::new(block);
@@ -31,13 +31,13 @@ fn readdir_block<T>(
 
 		let name = unsafe { OsStr::from_encoded_bytes_unchecked(name) };
 		let kind = match kind {
-			DT_FIFO => FileType::NamedPipe,
-			DT_CHR => FileType::CharDevice,
-			DT_DIR => FileType::Directory,
-			DT_BLK => FileType::BlockDevice,
-			DT_REG => FileType::RegularFile,
-			DT_LNK => FileType::Symlink,
-			DT_SOCK => FileType::Socket,
+			DT_FIFO => InodeType::NamedPipe,
+			DT_CHR => InodeType::CharDevice,
+			DT_DIR => InodeType::Directory,
+			DT_BLK => InodeType::BlockDevice,
+			DT_REG => InodeType::RegularFile,
+			DT_LNK => InodeType::Symlink,
+			DT_SOCK => InodeType::Socket,
 			DT_WHT => {
 				log::warn!("readdir_block({inr}): encountered a whiteout entry: {name:?}");
 				continue;
@@ -72,7 +72,7 @@ impl<R: Read + Seek> Ufs<R> {
 	pub fn dir_iter<T>(
 		&mut self,
 		inr: InodeNum,
-		mut f: impl FnMut(&OsStr, InodeNum, FileType) -> Option<T>,
+		mut f: impl FnMut(&OsStr, InodeNum, InodeType) -> Option<T>,
 	) -> IoResult<Option<T>> {
 		let ino = self.read_inode(inr)?;
 		let mut block = vec![0u8; self.superblock.bsize as usize];

rufs/src/ufs/inode.rs

@@ -2,6 +2,11 @@ use super::*;
 use crate::{err, InodeNum};
 
 impl<R: Read + Seek> Ufs<R> {
+	pub fn inode_attr(&mut self, inr: InodeNum) -> IoResult<InodeAttr> {
+		let ino = self.read_inode(inr)?;
+		Ok(ino.as_attr(inr))
+	}
+
 	pub fn inode_read(
 		&mut self,
 		inr: InodeNum,
@@ -34,7 +39,7 @@ impl<R: Read + Seek> Ufs<R> {
 		Ok(boff)
 	}
 
-	pub fn read_inode(&mut self, inr: InodeNum) -> IoResult<Inode> {
+	pub(super) fn read_inode(&mut self, inr: InodeNum) -> IoResult<Inode> {
 		let off = self.superblock.ino_to_fso(inr);
 		let ino: Inode = self.file.decode_at(off)?;
 

rufs/src/ufs/mod.rs

@@ -8,8 +8,6 @@ use std::{
 	path::Path,
 };
 
-use fuser::FileType;
-
 mod dir;
 mod inode;
 mod symlink;
@@ -68,7 +66,12 @@ impl<R: Read + Seek> Ufs<R> {
 		let config = match magic {
 			[0x19, 0x01, 0x54, 0x19] => Config::little(),
 			[0x19, 0x54, 0x01, 0x19] => Config::big(),
-			_ => iobail!(ErrorKind::InvalidInput, "invalid superblock magic number: {magic:?}"),
+			_ => {
+				iobail!(
+					ErrorKind::InvalidInput,
+					"invalid superblock magic number: {magic:?}"
+				)
+			}
 		};
 		// FIXME: Choose based on hash of input or so, to excercise BE as well with introducing non-determinism
 		#[cfg(fuzzing)]
@@ -79,7 +82,11 @@ impl<R: Read + Seek> Ufs<R> {
 		let superblock: Superblock = file.decode_at(SBLOCK_UFS2 as u64)?;
 		#[cfg(not(fuzzing))]
 		if superblock.magic != FS_UFS2_MAGIC {
-			iobail!(ErrorKind::InvalidInput, "invalid superblock magic number: {}", superblock.magic);
+			iobail!(
+				ErrorKind::InvalidInput,
+				"invalid superblock magic number: {}",
+				superblock.magic
+			);
 		}
 		let mut s = Self { file, superblock };
 		#[cfg(not(fuzzing))]

rufs/src/ufs/symlink.rs

@@ -5,7 +5,7 @@ impl<R: Read + Seek> Ufs<R> {
 	pub fn symlink_read(&mut self, inr: InodeNum) -> IoResult<Vec<u8>> {
 		let ino = self.read_inode(inr)?;
 
-		if ino.kind() != FileType::Symlink {
+		if ino.mode & S_IFMT != S_IFLNK {
 			return Err(IoError::from_raw_os_error(libc::EINVAL));
 		}