feat: add ftruncate/fchmod/truncate syscalls

Author: zyuiop

src/fd/mod.rs

@@ -314,6 +314,16 @@ pub(crate) trait ObjectInterface: Sync + Send + core::fmt::Debug {
 		Err(io::Error::ENOSYS)
 	}
 
+	/// Truncates the file
+	async fn truncate(&self, _size: usize) -> io::Result<()> {
+		Err(io::Error::ENOSYS)
+	}
+
+	/// Changes access permissions to the file
+	async fn chmod(&self, _access_permission: AccessPermission) -> io::Result<()> {
+		Err(io::Error::ENOSYS)
+	}
+
 	/// `isatty` returns `true` for a terminal device
 	async fn isatty(&self) -> io::Result<bool> {
 		Ok(false)
@@ -336,6 +346,12 @@ pub(crate) fn lseek(fd: FileDescriptor, offset: isize, whence: SeekWhence) -> io
 	block_on(obj.lseek(offset, whence), None)
 }
 
+pub(crate) fn chmod(fd: FileDescriptor, mode: AccessPermission) -> io::Result<()> {
+	let obj = get_object(fd)?;
+
+	block_on(obj.chmod(mode), None)
+}
+
 pub(crate) fn write(fd: FileDescriptor, buf: &[u8]) -> io::Result<usize> {
 	let obj = get_object(fd)?;
 
@@ -346,6 +362,11 @@ pub(crate) fn write(fd: FileDescriptor, buf: &[u8]) -> io::Result<usize> {
 	block_on(obj.write(buf), None)
 }
 
+pub(crate) fn truncate(fd: FileDescriptor, length: usize) -> io::Result<()> {
+	let obj = get_object(fd)?;
+	block_on(obj.truncate(length), None)
+}
+
 async fn poll_fds(fds: &mut [PollFd]) -> io::Result<u64> {
 	future::poll_fn(|cx| {
 		let mut counter: u64 = 0;

src/fs/fuse.rs

@@ -22,14 +22,14 @@ use crate::drivers::pci::get_filesystem_driver;
 use crate::drivers::virtio::virtqueue::error::VirtqError;
 use crate::executor::block_on;
 use crate::fd::PollEvent;
+use crate::fs::fuse::ops::SetAttrValidFields;
 use crate::fs::{
 	self, AccessPermission, DirectoryEntry, FileAttr, NodeKind, ObjectInterface, OpenOption,
 	SeekWhence, VfsNode,
 };
 use crate::mm::device_alloc::DeviceAlloc;
 use crate::time::{time_t, timespec};
 use crate::{arch, io};
-
 // response out layout eg @ https://github.com/zargony/fuse-rs/blob/bf6d1cf03f3277e35b580f3c7b9999255d72ecf3/src/ll/request.rs#L44
 // op in/out sizes/layout: https://github.com/hanwen/go-fuse/blob/204b45dba899dfa147235c255908236d5fde2d32/fuse/opcode.go#L439
 // possible responses for command: qemu/tools/virtiofsd/fuse_lowlevel.h
@@ -64,7 +64,7 @@ pub(crate) mod ops {
 
 	use super::Cmd;
 	use crate::fd::PollEvent;
-	use crate::fs::SeekWhence;
+	use crate::fs::{FileAttr, SeekWhence};
 
 	#[repr(C)]
 	#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
@@ -267,6 +267,76 @@ pub(crate) mod ops {
 		}
 	}
 
+	#[derive(Debug)]
+	pub(crate) struct Setattr;
+
+	impl Op for Setattr {
+		const OP_CODE: fuse_opcode = fuse_opcode::FUSE_SETATTR;
+		type InStruct = fuse_setattr_in;
+		type InPayload = ();
+		type OutStruct = fuse_attr_out;
+		type OutPayload = ();
+	}
+
+	bitflags! {
+		#[derive(Debug, Copy, Clone, Default)]
+		pub struct SetAttrValidFields: u32 {
+			const FATTR_MODE = 1 << 0;
+			const FATTR_UID = 1 << 1;
+			const FATTR_GID = 1 << 2;
+			const FATTR_SIZE = 1 << 3;
+			const FATTR_ATIME = 1 << 4;
+			const FATTR_MTIME = 1 << 5;
+			const FATTR_FH = 1 << 6;
+			const FATTR_ATIME_NOW = 1 << 7;
+			const FATTR_MTIME_NOW = 1 << 8;
+			const FATTR_LOCKOWNER = 1 << 9;
+			const FATTR_CTIME = 1 << 10;
+			const FATTR_KILL_SUIDGID = 1 << 11;
+		}
+	}
+
+	impl Setattr {
+		pub(crate) fn create(
+			nid: u64,
+			fh: u64,
+			attr: FileAttr,
+			valid_attr: SetAttrValidFields,
+		) -> (Cmd<Self>, u32) {
+			let cmd = Cmd::new(
+				nid,
+				fuse_setattr_in {
+					valid: valid_attr
+						.difference(
+							// Remove unsupported attributes
+							SetAttrValidFields::FATTR_LOCKOWNER,
+						)
+						.bits(),
+					padding: 0,
+					fh,
+
+					// Fuse attributes mapping: https://github.com/libfuse/libfuse/blob/fc1c8da0cf8a18d222cb1feed0057ba44ea4d18f/lib/fuse_lowlevel.c#L105
+					size: attr.st_size as u64,
+					atime: attr.st_atim.tv_sec as u64,
+					atimensec: attr.st_atim.tv_nsec as u32,
+					mtime: attr.st_ctim.tv_sec as u64,
+					mtimensec: attr.st_ctim.tv_nsec as u32,
+					ctime: attr.st_ctim.tv_sec as u64,
+					ctimensec: attr.st_ctim.tv_nsec as u32,
+					mode: attr.st_mode.bits(),
+					unused4: 0,
+					uid: attr.st_uid,
+					gid: attr.st_gid,
+					unused5: 0,
+
+					lock_owner: 0, // unsupported
+				},
+			);
+
+			(cmd, 0)
+		}
+	}
+
 	#[derive(Debug)]
 	pub(crate) struct Readlink;
 
@@ -755,6 +825,23 @@ impl FuseFileHandleInner {
 			Err(io::Error::EIO)
 		}
 	}
+
+	fn set_attr(&mut self, attr: FileAttr, valid: SetAttrValidFields) -> io::Result<FileAttr> {
+		debug!("FUSE setattr");
+		if let (Some(nid), Some(fh)) = (self.fuse_nid, self.fuse_fh) {
+			let (cmd, rsp_payload_len) = ops::Setattr::create(nid, fh, attr, valid);
+			let rsp = get_filesystem_driver()
+				.ok_or(io::Error::ENOSYS)?
+				.lock()
+				.send_command(cmd, rsp_payload_len)?;
+			if rsp.headers.out_header.error < 0 {
+				return Err(io::Error::EIO);
+			}
+			Ok(rsp.headers.op_header.attr.into())
+		} else {
+			Err(io::Error::EIO)
+		}
+	}
 }
 
 impl Drop for FuseFileHandleInner {
@@ -801,6 +888,32 @@ impl ObjectInterface for FuseFileHandle {
 	async fn fstat(&self) -> io::Result<FileAttr> {
 		self.0.lock().await.fstat()
 	}
+
+	async fn truncate(&self, size: usize) -> io::Result<()> {
+		let attr = FileAttr {
+			st_size: size.try_into().unwrap(),
+			..FileAttr::default()
+		};
+
+		self.0
+			.lock()
+			.await
+			.set_attr(attr, SetAttrValidFields::FATTR_SIZE)
+			.map(|_| ())
+	}
+
+	async fn chmod(&self, access_permission: AccessPermission) -> io::Result<()> {
+		let attr = FileAttr {
+			st_mode: access_permission,
+			..FileAttr::default()
+		};
+
+		self.0
+			.lock()
+			.await
+			.set_attr(attr, SetAttrValidFields::FATTR_MODE)
+			.map(|_| ())
+	}
 }
 
 impl Clone for FuseFileHandle {

src/fs/mem.rs

@@ -252,6 +252,19 @@ impl ObjectInterface for RamFileInterface {
 		let guard = self.inner.read().await;
 		Ok(guard.attr)
 	}
+
+	async fn truncate(&self, size: usize) -> io::Result<()> {
+		let mut guard = self.inner.write().await;
+		guard.data.resize(size, 0);
+		guard.attr.st_size = size as i64;
+		Ok(())
+	}
+
+	async fn chmod(&self, access_permission: AccessPermission) -> io::Result<()> {
+		let mut guard = self.inner.write().await;
+		guard.attr.st_mode = access_permission;
+		Ok(())
+	}
 }
 
 impl RamFileInterface {

src/fs/mod.rs

@@ -14,6 +14,7 @@ use hermit_sync::{InterruptSpinMutex, OnceCell};
 use mem::MemDirectory;
 use num_enum::{IntoPrimitive, TryFromPrimitive};
 
+use crate::executor::block_on;
 use crate::fd::{AccessPermission, ObjectInterface, OpenOption, insert_object, remove_object};
 use crate::io;
 use crate::io::Write;
@@ -440,6 +441,17 @@ where
 	}
 }
 
+pub fn truncate(name: &str, size: usize) -> io::Result<()> {
+	with_relative_filename(name, |name| {
+		let fs = FILESYSTEM.get().ok_or(io::Error::EINVAL)?;
+		if let Ok(file) = fs.open(name, OpenOption::O_TRUNC, AccessPermission::empty()) {
+			block_on(file.truncate(size), None)
+		} else {
+			Err(io::Error::EBADF)
+		}
+	})
+}
+
 pub fn open(name: &str, flags: OpenOption, mode: AccessPermission) -> io::Result<FileDescriptor> {
 	// mode is 0x777 (0b0111_0111_0111), when flags | O_CREAT, else 0
 	// flags is bitmask of O_DEC_* defined above.

src/syscalls/mod.rs

@@ -436,9 +436,6 @@ pub unsafe extern "C" fn sys_faccessat(
 #[hermit_macro::system]
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sys_access(name: *const c_char, flags: i32) -> i32 {
-	// This is an implementation of libc's access, not of linux's faccessat
-	// See https://linux.die.net/man/2/faccessat for differences
-
 	let access_option = AccessOption::from_bits_truncate(flags);
 	if access_option.bits() != flags {
 		return -crate::errno::EINVAL;
@@ -466,6 +463,19 @@ pub unsafe extern "C" fn sys_access(name: *const c_char, flags: i32) -> i32 {
 	}
 }
 
+#[hermit_macro::system]
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sys_fchmod(fd: FileDescriptor, mode: u32) -> i32 {
+	let access_permission = AccessPermission::from_bits_truncate(mode);
+	if access_permission.bits() != mode {
+		return -crate::errno::EINVAL;
+	}
+
+	crate::fd::chmod(fd, access_permission)
+		.map(|()| 0)
+		.unwrap_or_else(|e| -i32::from(e))
+}
+
 #[hermit_macro::system]
 #[unsafe(no_mangle)]
 pub extern "C" fn sys_close(fd: FileDescriptor) -> i32 {
@@ -546,6 +556,22 @@ pub unsafe extern "C" fn sys_write(fd: FileDescriptor, buf: *const u8, len: usiz
 	unsafe { write(fd, buf, len) }
 }
 
+#[hermit_macro::system]
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sys_ftruncate(fd: FileDescriptor, size: usize) -> i32 {
+	crate::fd::truncate(fd, size).map_or_else(|e| -i32::from(e), |()| 0)
+}
+
+#[hermit_macro::system]
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sys_truncate(path: *const c_char, size: usize) -> i32 {
+	let Ok(path) = unsafe { CStr::from_ptr(path) }.to_str() else {
+		return -crate::errno::EINVAL;
+	};
+
+	crate::fs::truncate(path, size).map_or_else(|e| -i32::from(e), |()| 0)
+}
+
 /// `write()` attempts to write `nbyte` of data to the object referenced by the
 /// descriptor `fd` from a buffer. `writev()` performs the same
 /// action, but gathers the output data from the `iovcnt` buffers specified by the