diff --git a/src/kernel/src/arch/mod.rs b/src/kernel/src/arch/mod.rs
index 60486c3ba..25cfd9903 100644
--- a/src/kernel/src/arch/mod.rs
+++ b/src/kernel/src/arch/mod.rs
@@ -31,7 +31,7 @@ impl MachDep {
         mach
     }
 
-    fn sysarch(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sysarch(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let op: u32 = i.args[0].try_into().unwrap();
         let parms: *mut u8 = i.args[1].into();
         let mut pcb = td.pcb_mut();
diff --git a/src/kernel/src/budget/mod.rs b/src/kernel/src/budget/mod.rs
index eae69f220..c977a4bfe 100644
--- a/src/kernel/src/budget/mod.rs
+++ b/src/kernel/src/budget/mod.rs
@@ -28,7 +28,11 @@ impl BudgetManager {
         budgets.alloc(Entry::new(Some(name), Arc::new(budget), 0x2000))
     }
 
-    fn sys_budget_get_ptype(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_budget_get_ptype(
+        self: &Arc<Self>,
+        td: &Arc<VThread>,
+        i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         // Check if PID is our process.
         let pid: i32 = i.args[0].try_into().unwrap();
 
diff --git a/src/kernel/src/dmem/mod.rs b/src/kernel/src/dmem/mod.rs
index 8c41a5aab..22b168096 100644
--- a/src/kernel/src/dmem/mod.rs
+++ b/src/kernel/src/dmem/mod.rs
@@ -111,7 +111,11 @@ impl DmemManager {
         Ok(dmem)
     }
 
-    fn sys_dmem_container(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_dmem_container(
+        self: &Arc<Self>,
+        td: &Arc<VThread>,
+        i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         let dmem_id: i32 = i.args[0].try_into().unwrap();
 
         let dmem_container = td.proc().dmem_container_mut();
@@ -126,7 +130,11 @@ impl DmemManager {
         Ok(current_container.into())
     }
 
-    fn sys_blockpool_open(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_blockpool_open(
+        self: &Arc<Self>,
+        td: &Arc<VThread>,
+        i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         let flags: u32 = i.args[0].try_into().unwrap();
 
         if flags & 0xffafffff != 0 {
@@ -145,7 +153,7 @@ impl DmemManager {
         Ok(fd.into())
     }
 
-    fn sys_blockpool_map(self: &Arc<Self>, _: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_blockpool_map(self: &Arc<Self>, _: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let addr: usize = i.args[0].into();
         let len: usize = i.args[1].into();
         let mem_type: i32 = i.args[2].try_into().unwrap();
@@ -160,15 +168,27 @@ impl DmemManager {
         todo!()
     }
 
-    fn sys_blockpool_unmap(self: &Arc<Self>, _: &VThread, _i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_blockpool_unmap(
+        self: &Arc<Self>,
+        _: &Arc<VThread>,
+        _i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         todo!()
     }
 
-    fn sys_blockpool_batch(self: &Arc<Self>, _: &VThread, _i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_blockpool_batch(
+        self: &Arc<Self>,
+        _: &Arc<VThread>,
+        _i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         todo!()
     }
 
-    fn sys_blockpool_move(self: &Arc<Self>, _: &VThread, _i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_blockpool_move(
+        self: &Arc<Self>,
+        _: &Arc<VThread>,
+        _i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         todo!()
     }
 }
diff --git a/src/kernel/src/fs/mod.rs b/src/kernel/src/fs/mod.rs
index 09f6d1b7f..2b9c84e6a 100644
--- a/src/kernel/src/fs/mod.rs
+++ b/src/kernel/src/fs/mod.rs
@@ -365,7 +365,7 @@ impl Fs {
         }
     }
 
-    fn sys_read(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_read(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let ptr: *mut u8 = i.args[1].into();
         let len: IoLen = i.args[2].try_into()?;
@@ -375,7 +375,7 @@ impl Fs {
         todo!("sys_read")
     }
 
-    fn sys_write(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_write(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let ptr: *const u8 = i.args[1].into();
         let len: IoLen = i.args[2].try_into()?;
@@ -385,7 +385,7 @@ impl Fs {
         todo!("sys_write")
     }
 
-    fn sys_open(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_open(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         // Get arguments.
         let path = unsafe { i.args[0].to_path()?.unwrap() };
         let flags: OpenFlags = i.args[1].try_into().unwrap();
@@ -428,7 +428,7 @@ impl Fs {
         Ok(fd.into())
     }
 
-    fn sys_close(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_close(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
 
         info!("Closing fd {fd}.");
@@ -438,7 +438,7 @@ impl Fs {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_ioctl(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_ioctl(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         // Our IoCmd contains both the command and the argument (if there is one).
         let cmd = IoCmd::try_from_raw_parts(i.args[1].into(), i.args[2].into())?;
@@ -474,7 +474,7 @@ impl Fs {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_revoke(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_revoke(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let path = unsafe { i.args[0].to_path()?.unwrap() };
 
         info!("Revoking access to {path}.");
@@ -511,7 +511,7 @@ impl Fs {
         Ok(())
     }
 
-    fn sys_readv(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_readv(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let iovec: *mut IoVec = i.args[1].into();
         let count: u32 = i.args[2].try_into().unwrap();
@@ -523,7 +523,7 @@ impl Fs {
         todo!()
     }
 
-    fn sys_writev(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_writev(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let iovec: *const IoVec = i.args[1].into();
         let iovcnt: u32 = i.args[2].try_into().unwrap();
@@ -537,7 +537,7 @@ impl Fs {
         todo!()
     }
 
-    fn sys_stat(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_stat(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let path = unsafe { i.args[0].to_path() }?.unwrap();
         let stat_out: *mut Stat = i.args[1].into();
 
@@ -555,7 +555,7 @@ impl Fs {
         self.statat(AtFlags::empty(), At::Cwd, path, td)
     }
 
-    fn sys_fstat(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_fstat(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let stat_out: *mut Stat = i.args[1].into();
 
@@ -577,7 +577,7 @@ impl Fs {
         Ok(stat)
     }
 
-    fn sys_lstat(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_lstat(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let path = unsafe { i.args[0].to_path() }?.unwrap();
         let stat_out: *mut Stat = i.args[1].into();
 
@@ -597,7 +597,7 @@ impl Fs {
         self.statat(AtFlags::SYMLINK_NOFOLLOW, At::Cwd, path, td)
     }
 
-    fn sys_pread(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_pread(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let ptr: *mut u8 = i.args[1].into();
         let len: IoLen = i.args[2].try_into()?;
@@ -611,7 +611,7 @@ impl Fs {
         Ok(read.into())
     }
 
-    fn sys_pwrite(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_pwrite(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let ptr: *const u8 = i.args[1].into();
         let len: IoLen = i.args[2].try_into()?;
@@ -625,7 +625,7 @@ impl Fs {
         Ok(written.into())
     }
 
-    fn sys_preadv(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_preadv(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         // Get arguments.
         let fd: i32 = i.args[0].try_into().unwrap();
         let iovec: *mut IoVecMut = i.args[1].into();
@@ -680,7 +680,7 @@ impl Fs {
         todo!()
     }
 
-    fn sys_pwritev(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_pwritev(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         // Get arguments.
         let fd: i32 = i.args[0].try_into().unwrap();
         let iovec: *const IoVec = i.args[1].into();
@@ -729,7 +729,7 @@ impl Fs {
         todo!()
     }
 
-    fn sys_fstatat(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_fstatat(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let dirfd: i32 = i.args[0].try_into().unwrap();
         let path = unsafe { i.args[1].to_path() }?.unwrap();
         let stat_out: *mut Stat = i.args[2].into();
@@ -759,7 +759,7 @@ impl Fs {
         todo!()
     }
 
-    fn sys_mkdir(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_mkdir(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let path = unsafe { i.args[0].to_path() }?.unwrap();
         let mode: u32 = i.args[1].try_into().unwrap();
 
@@ -767,7 +767,7 @@ impl Fs {
     }
 
     #[allow(unused_variables)]
-    fn sys_poll(self: &Arc<Self>, _td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_poll(self: &Arc<Self>, _td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fds: *mut PollFd = i.args[0].into();
         let nfds: u32 = i.args[1].try_into().unwrap();
         let timeout: i32 = i.args[2].try_into().unwrap();
@@ -779,7 +779,7 @@ impl Fs {
         todo!()
     }
 
-    fn sys_lseek(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_lseek(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let mut offset: i64 = i.args[1].into();
         let whence: Whence = {
@@ -817,7 +817,7 @@ impl Fs {
         todo!()
     }
 
-    fn sys_truncate(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_truncate(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let path = unsafe { i.args[0].to_path() }?.unwrap();
         let length = i.args[1].into();
 
@@ -836,7 +836,7 @@ impl Fs {
         todo!()
     }
 
-    fn sys_ftruncate(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_ftruncate(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd = i.args[0].try_into().unwrap();
         let length = i.args[1].into();
 
@@ -859,7 +859,7 @@ impl Fs {
         Ok(())
     }
 
-    fn sys_mkdirat(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_mkdirat(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         td.priv_check(Privilege::SCE683)?;
 
         let fd: i32 = i.args[0].try_into().unwrap();
diff --git a/src/kernel/src/ipmi/mod.rs b/src/kernel/src/ipmi/mod.rs
index 3423ecf1c..92b43ace3 100644
--- a/src/kernel/src/ipmi/mod.rs
+++ b/src/kernel/src/ipmi/mod.rs
@@ -1,15 +1,15 @@
-use crate::{
-    info,
-    process::VThread,
-    syscalls::{SysErr, SysIn, SysOut, Syscalls},
-    warn,
+use self::cmd::{
+    ClientDisconnectArgs, ConnectArgs, CreateClientArgs, CreateServerArgs, CreateSessionArgs,
+    InvokeAsyncMethodArgs, InvokeSyncMethodArgs, IpmiCommand, PollEventFlagArgs,
+    ServerReceivePacketArgs, TryGetMessagetArgs, TryGetResultArgs,
 };
+use crate::info;
+use crate::process::VThread;
+use crate::syscalls::{SysErr, SysIn, SysOut, Syscalls};
 use std::sync::Arc;
 
 mod cmd;
 
-use cmd::*;
-
 pub struct IpmiManager {}
 
 impl IpmiManager {
@@ -21,7 +21,7 @@ impl IpmiManager {
         ipmi
     }
 
-    fn sys_ipmi_mgr_call(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_ipmi_mgr_call(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         const BUF_SIZE: usize = 0x40;
 
         let cmd: u32 = i.args[0].try_into().unwrap();
diff --git a/src/kernel/src/kqueue/mod.rs b/src/kernel/src/kqueue/mod.rs
index a5e973efb..a434d2405 100644
--- a/src/kernel/src/kqueue/mod.rs
+++ b/src/kernel/src/kqueue/mod.rs
@@ -20,11 +20,11 @@ impl KernelQueueManager {
         kq
     }
 
-    fn sys_kqueueex(self: &Arc<Self>, _: &VThread, _: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_kqueueex(self: &Arc<Self>, _: &Arc<VThread>, _: &SysIn) -> Result<SysOut, SysErr> {
         todo!()
     }
 
-    fn sys_kqueue(self: &Arc<Self>, td: &VThread, _: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_kqueue(self: &Arc<Self>, td: &Arc<VThread>, _: &SysIn) -> Result<SysOut, SysErr> {
         let filedesc = td.proc().files();
 
         let fd = filedesc.alloc_with_budget::<Infallible>(
diff --git a/src/kernel/src/namedobj/mod.rs b/src/kernel/src/namedobj/mod.rs
index 611185004..fba7544b3 100644
--- a/src/kernel/src/namedobj/mod.rs
+++ b/src/kernel/src/namedobj/mod.rs
@@ -16,7 +16,11 @@ impl NamedObjManager {
         namedobj
     }
 
-    fn sys_namedobj_create(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_namedobj_create(
+        self: &Arc<Self>,
+        td: &Arc<VThread>,
+        i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         // Get arguments.
         let name = unsafe { i.args[0].to_str(32) }?.ok_or(SysErr::Raw(EINVAL))?;
         let data: usize = i.args[1].into();
diff --git a/src/kernel/src/net/mod.rs b/src/kernel/src/net/mod.rs
index 4131c6c50..97be8d5a5 100644
--- a/src/kernel/src/net/mod.rs
+++ b/src/kernel/src/net/mod.rs
@@ -40,7 +40,7 @@ impl NetManager {
         net
     }
 
-    fn sys_recvmsg(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_recvmsg(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let msg: *mut MsgHdr = i.args[1].into();
         let flags = {
@@ -55,7 +55,7 @@ impl NetManager {
         todo!()
     }
 
-    fn sys_sendmsg(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_sendmsg(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let msg: *const MsgHdr = i.args[1].into();
         let flags = {
@@ -73,7 +73,7 @@ impl NetManager {
     }
 
     #[allow(unused_variables)] // TODO: Remove this when implementing
-    fn sys_recvfrom(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_recvfrom(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let buf: *mut u8 = i.args[1].into();
         let buflen: usize = i.args[2].into();
@@ -86,7 +86,7 @@ impl NetManager {
     }
 
     #[allow(unused_variables)] // TODO: Remove this when implementing
-    fn sys_accept(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_accept(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let addr: *mut u8 = i.args[1].into();
         let addrlen: *mut u32 = i.args[2].try_into().unwrap();
@@ -94,7 +94,7 @@ impl NetManager {
         todo!()
     }
 
-    fn sys_bind(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_bind(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let ptr: *const u8 = i.args[1].into();
         let len: i32 = i.args[2].try_into().unwrap();
@@ -120,7 +120,7 @@ impl NetManager {
         Ok(())
     }
 
-    fn sys_netcontrol(self: &Arc<Self>, _: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_netcontrol(self: &Arc<Self>, _: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let op: i32 = i.args[1].try_into().unwrap();
         let ptr: *mut u8 = i.args[2].into();
@@ -172,7 +172,7 @@ impl NetManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_setsockopt(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_setsockopt(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let level: i32 = i.args[1].try_into().unwrap();
         let name: i32 = i.args[2].try_into().unwrap();
@@ -184,7 +184,7 @@ impl NetManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_listen(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_listen(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let backlog: i32 = i.args[1].try_into().unwrap();
         let file = td.proc().files().get(fd)?;
@@ -198,7 +198,7 @@ impl NetManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_socket(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_socket(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let domain: i32 = i.args[0].try_into().unwrap();
         let ty: i32 = i.args[1].try_into().unwrap();
         let proto: Option<NonZeroI32> = i.args[2].try_into().unwrap();
@@ -226,7 +226,7 @@ impl NetManager {
         Ok(fd.into())
     }
 
-    fn sys_connect(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_connect(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let ptr: *const u8 = i.args[1].into();
         let len: i32 = i.args[2].try_into().unwrap();
@@ -245,7 +245,7 @@ impl NetManager {
         todo!("connect")
     }
 
-    fn sys_getsockopt(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_getsockopt(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let level: i32 = i.args[1].try_into().unwrap();
         let name: i32 = i.args[2].try_into().unwrap();
@@ -257,7 +257,7 @@ impl NetManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_socketex(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_socketex(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let name = unsafe { i.args[0].to_str(32)? };
         let domain: i32 = i.args[1].try_into().unwrap();
         let ty: i32 = i.args[2].try_into().unwrap();
@@ -286,7 +286,7 @@ impl NetManager {
         Ok(fd.into())
     }
 
-    fn sys_socketclose(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_socketclose(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
 
         info!("Closing socket at fd {fd}.");
@@ -297,7 +297,7 @@ impl NetManager {
     }
 
     #[allow(unused_variables)] // TODO: Remove this when implementing
-    fn sys_sendto(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_sendto(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let fd: i32 = i.args[0].try_into().unwrap();
         let buf: *const u8 = i.args[1].into();
         let buflen: usize = i.args[2].into();
diff --git a/src/kernel/src/osem/mod.rs b/src/kernel/src/osem/mod.rs
index 1b485754b..47538bda6 100644
--- a/src/kernel/src/osem/mod.rs
+++ b/src/kernel/src/osem/mod.rs
@@ -16,7 +16,7 @@ impl OsemManager {
         osem
     }
 
-    fn sys_osem_create(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_osem_create(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let name = unsafe { i.args[0].to_str(32) }?.unwrap();
         let flags = {
             let flags = i.args[1].try_into().unwrap();
diff --git a/src/kernel/src/process/mod.rs b/src/kernel/src/process/mod.rs
index 5b24bc593..bd08fab6d 100644
--- a/src/kernel/src/process/mod.rs
+++ b/src/kernel/src/process/mod.rs
@@ -121,11 +121,11 @@ impl ProcManager {
         Ok(proc)
     }
 
-    fn sys_getpid(self: &Arc<Self>, td: &VThread, _: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_getpid(self: &Arc<Self>, td: &Arc<VThread>, _: &SysIn) -> Result<SysOut, SysErr> {
         Ok(td.proc().id().into())
     }
 
-    fn sys_setlogin(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_setlogin(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         // Check current thread privilege.
         td.priv_check(Privilege::PROC_SETLOGIN)?;
 
@@ -151,7 +151,7 @@ impl ProcManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_setsid(self: &Arc<Self>, td: &VThread, _: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_setsid(self: &Arc<Self>, td: &Arc<VThread>, _: &SysIn) -> Result<SysOut, SysErr> {
         // Check if current thread has privilege.
         td.priv_check(Privilege::SCE680)?;
 
@@ -174,7 +174,7 @@ impl ProcManager {
         Ok(pid.into())
     }
 
-    fn sys_sigaction(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_sigaction(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         // Get arguments.
         let sig = {
             let sig: i32 = i.args[0].try_into().unwrap();
@@ -302,7 +302,7 @@ impl ProcManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_thr_self(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_thr_self(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let id: *mut i64 = i.args[0].into();
 
         unsafe { *id = td.id().get().into() };
@@ -310,7 +310,7 @@ impl ProcManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_thr_set_name(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_thr_set_name(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let tid: i64 = i.args[0].into();
         let name: Option<&str> = unsafe { i.args[1].to_str(32) }?;
         let proc = td.proc();
@@ -338,7 +338,7 @@ impl ProcManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_rtprio_thread(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_rtprio_thread(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let function: RtpFunction = i.args[0].try_into()?;
         let lwpid: i32 = i.args[1].try_into().unwrap();
         let rtp: *mut RtPrio = i.args[2].into();
@@ -379,7 +379,11 @@ impl ProcManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_cpuset_getaffinity(self: &Arc<Self>, _: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_cpuset_getaffinity(
+        self: &Arc<Self>,
+        _: &Arc<VThread>,
+        i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         // Get arguments.
         let level: CpuLevel = i.args[0].try_into()?;
         let which: CpuWhich = i.args[1].try_into()?;
@@ -423,7 +427,11 @@ impl ProcManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_cpuset_setaffinity(self: &Arc<Self>, _: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_cpuset_setaffinity(
+        self: &Arc<Self>,
+        _: &Arc<VThread>,
+        i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         let level: CpuLevel = i.args[0].try_into()?;
         let which: CpuWhich = i.args[1].try_into()?;
         let id: i64 = i.args[2].into();
@@ -441,13 +449,13 @@ impl ProcManager {
         todo!()
     }
 
-    fn sys_is_in_sandbox(self: &Arc<Self>, td: &VThread, _: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_is_in_sandbox(self: &Arc<Self>, td: &Arc<VThread>, _: &SysIn) -> Result<SysOut, SysErr> {
         let v = !Arc::ptr_eq(&td.proc().files().root(), &self.fs.root());
 
         Ok(v.into())
     }
 
-    fn sys_get_authinfo(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_get_authinfo(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         // Get arguments.
         let pid: Option<NonZeroI32> = i.args[0].try_into().unwrap();
         let buf: *mut AuthInfo = i.args[1].into();
@@ -495,7 +503,11 @@ impl ProcManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_randomized_path(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_randomized_path(
+        self: &Arc<Self>,
+        td: &Arc<VThread>,
+        i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         let set = i.args[0];
         let get: *mut c_char = i.args[1].into();
         let len: *mut usize = i.args[2].into();
@@ -525,7 +537,11 @@ impl ProcManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_get_proc_type_info(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_get_proc_type_info(
+        self: &Arc<Self>,
+        td: &Arc<VThread>,
+        i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         // Check buffer size.
         let info: *mut ProcTypeInfo = i.args[0].into();
 
diff --git a/src/kernel/src/process/proc.rs b/src/kernel/src/process/proc.rs
index 10801a906..523124a2d 100644
--- a/src/kernel/src/process/proc.rs
+++ b/src/kernel/src/process/proc.rs
@@ -187,7 +187,7 @@ impl VProc {
         &self.uptc
     }
 
-    fn sys_thr_new(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_thr_new(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let param: *const ThrParam = i.args[0].into();
         let param_size: i32 = i.args[1].try_into().unwrap();
 
diff --git a/src/kernel/src/regmgr/mod.rs b/src/kernel/src/regmgr/mod.rs
index ad2a95a93..487ec72f6 100644
--- a/src/kernel/src/regmgr/mod.rs
+++ b/src/kernel/src/regmgr/mod.rs
@@ -27,7 +27,7 @@ impl RegMgr {
         mgr
     }
 
-    fn sys_regmgr_call(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_regmgr_call(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         // Get arguments.
         let op: u32 = i.args[0].try_into().unwrap();
         let buf: *mut i32 = i.args[2].into();
@@ -332,7 +332,7 @@ impl RegMgr {
         None
     }
 
-    fn sys_workaround8849(self: &Arc<Self>, _: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_workaround8849(self: &Arc<Self>, _: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let key = {
             let arg: usize = i.args[0].into();
             let key: u32 = arg.try_into().unwrap();
diff --git a/src/kernel/src/rtld/mod.rs b/src/kernel/src/rtld/mod.rs
index b3c0c0c50..08ab3c4a0 100644
--- a/src/kernel/src/rtld/mod.rs
+++ b/src/kernel/src/rtld/mod.rs
@@ -381,7 +381,7 @@ impl RuntimeLinker {
         unsafe { String::from_utf8_unchecked(nid) }
     }
 
-    fn sys_dynlib_dlsym(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_dynlib_dlsym(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         // Check if application is dynamic linking.
         let bin = td.proc().bin();
         let bin = bin.as_ref().ok_or(SysErr::Raw(EPERM))?;
@@ -420,7 +420,11 @@ impl RuntimeLinker {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_dynlib_get_list(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_dynlib_get_list(
+        self: &Arc<Self>,
+        td: &Arc<VThread>,
+        i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         // Get arguments.
         let buf: *mut u32 = i.args[0].into();
         let max: usize = i.args[1].into();
@@ -452,7 +456,11 @@ impl RuntimeLinker {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_dynlib_get_info(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_dynlib_get_info(
+        self: &Arc<Self>,
+        td: &Arc<VThread>,
+        i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         let handle: u32 = i.args[0].try_into().unwrap();
         let info = {
             let info_out: *mut DynlibInfo = i.args[1].into();
@@ -543,7 +551,11 @@ impl RuntimeLinker {
         Ok(info)
     }
 
-    fn sys_dynlib_load_prx(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_dynlib_load_prx(
+        self: &Arc<Self>,
+        td: &Arc<VThread>,
+        i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         // Not sure what is this. Maybe kernel only flags?
         let mut flags: u32 = i.args[1].try_into().unwrap();
 
@@ -631,7 +643,7 @@ impl RuntimeLinker {
 
     fn sys_dynlib_do_copy_relocations(
         self: &Arc<Self>,
-        td: &VThread,
+        td: &Arc<VThread>,
         _: &SysIn,
     ) -> Result<SysOut, SysErr> {
         let bin = td.proc().bin();
@@ -650,7 +662,7 @@ impl RuntimeLinker {
 
     fn sys_dynlib_get_proc_param(
         self: &Arc<Self>,
-        td: &VThread,
+        td: &Arc<VThread>,
         i: &SysIn,
     ) -> Result<SysOut, SysErr> {
         // Get arguments.
@@ -680,7 +692,7 @@ impl RuntimeLinker {
 
     fn sys_dynlib_process_needed_and_relocate(
         self: &Arc<Self>,
-        td: &VThread,
+        td: &Arc<VThread>,
         _: &SysIn,
     ) -> Result<SysOut, SysErr> {
         // Check if application is dynamic linking.
@@ -974,7 +986,11 @@ impl RuntimeLinker {
         }
     }
 
-    fn sys_dynlib_get_info_ex(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_dynlib_get_info_ex(
+        self: &Arc<Self>,
+        td: &Arc<VThread>,
+        i: &SysIn,
+    ) -> Result<SysOut, SysErr> {
         // Get arguments.
         let handle: u32 = i.args[0].try_into().unwrap();
         let flags: u32 = i.args[1].try_into().unwrap();
@@ -1103,7 +1119,7 @@ impl RuntimeLinker {
 
     fn sys_dynlib_get_obj_member(
         self: &Arc<Self>,
-        td: &VThread,
+        td: &Arc<VThread>,
         i: &SysIn,
     ) -> Result<SysOut, SysErr> {
         let handle: u32 = i.args[0].try_into().unwrap();
diff --git a/src/kernel/src/shm/mod.rs b/src/kernel/src/shm/mod.rs
index 15a68e649..c259d02cd 100644
--- a/src/kernel/src/shm/mod.rs
+++ b/src/kernel/src/shm/mod.rs
@@ -24,7 +24,7 @@ impl SharedMemoryManager {
         shm
     }
 
-    fn sys_shm_open(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_shm_open(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let path = unsafe { i.args[0].to_shm_path() }?.expect("invalid shm path");
         let flags: OpenFlags = i.args[1].try_into().unwrap();
         let mode: u32 = i.args[2].try_into().unwrap();
@@ -55,7 +55,7 @@ impl SharedMemoryManager {
     }
 
     #[allow(unused_variables)] // TODO: remove when implementing.
-    fn sys_shm_unlink(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_shm_unlink(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         todo!("sys_shm_unlink")
     }
 }
diff --git a/src/kernel/src/signal/mod.rs b/src/kernel/src/signal/mod.rs
index 2ac7e3625..fdb2222f6 100644
--- a/src/kernel/src/signal/mod.rs
+++ b/src/kernel/src/signal/mod.rs
@@ -23,7 +23,7 @@ impl SignalManager {
         mgr
     }
 
-    fn sys_sigprocmask(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_sigprocmask(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         // Get arguments.
         let how: MaskOp = i.args[0].try_into()?;
         let set: *const SignalSet = i.args[1].into();
diff --git a/src/kernel/src/syscalls/mod.rs b/src/kernel/src/syscalls/mod.rs
index 014fb32c0..691e51a11 100644
--- a/src/kernel/src/syscalls/mod.rs
+++ b/src/kernel/src/syscalls/mod.rs
@@ -1,6 +1,5 @@
 use crate::errno::ENOSYS;
 use crate::process::VThread;
-use crate::warn;
 use std::fmt::{Debug, Formatter};
 use std::sync::Arc;
 
@@ -13,34 +12,30 @@ mod input;
 mod output;
 
 /// Provides PS4 kernel routines for PS4 application and system libraries.
-pub struct Syscalls {
-    handlers: [Option<SyscallHandler>; 678],
-}
-
-type SyscallHandler = Box<dyn Fn(&VThread, &SysIn) -> Result<SysOut, SysErr> + Send + Sync>;
+pub struct Syscalls([Option<Handler>; 680]);
 
 impl Syscalls {
-    pub fn new() -> Self {
-        // Allows us to initialize the array with `None` without having to resort to non-const operations.
-        const NONE: Option<SyscallHandler> = None;
+    pub const fn new() -> Self {
+        // Allows us to initialize the array with `None` without having to resort to non-const
+        // operations.
+        const NONE: Option<Handler> = None;
 
-        Self {
-            handlers: [NONE; 678],
-        }
+        Self([NONE; 680])
     }
 
     /// # Panics
     /// If `id` is not a valid number or the syscall with identifier `id` is already registered.
-    pub fn register<O: Send + Sync + 'static>(
+    pub fn register<C: Send + Sync + 'static>(
         &mut self,
         id: u32,
-        o: &Arc<O>,
-        handler: fn(&Arc<O>, &VThread, &SysIn) -> Result<SysOut, SysErr>,
+        cx: &Arc<C>,
+        handler: fn(&Arc<C>, &Arc<VThread>, &SysIn) -> Result<SysOut, SysErr>,
     ) {
-        let o = o.clone();
+        let id: usize = id.try_into().unwrap();
+        let cx = cx.clone();
 
-        assert!(self.handlers[id as usize]
-            .replace(Box::new(move |td, i| handler(&o, td, i)))
+        assert!(self.0[id]
+            .replace(Box::new(move |td, i| handler(&cx, td, i)))
             .is_none());
     }
 
@@ -54,10 +49,11 @@ impl Syscalls {
         //
         // See https://github.com/freebsd/freebsd-src/blob/release/9.1.0/sys/kern/init_sysent.c#L36
         // for standard FreeBSD syscalls.
-        let handler = match self.handlers.get(i.id as usize) {
+        let id: usize = i.id.try_into().unwrap();
+        let handler = match self.0.get(id) {
             Some(Some(v)) => v,
             Some(None) => todo!(
-                "syscall {} at {:#x} on {} with args = ({:#x}, {:#x}, {:#x}, {:#x}, {:#x}, {:#x})",
+                "syscall {} at {:#x} on {} with args = [{:#x}, {:#x}, {:#x}, {:#x}, {:#x}, {:#x}]",
                 i.id,
                 i.offset,
                 i.module,
@@ -71,15 +67,11 @@ impl Syscalls {
             None => return ENOSYS.get().into(),
         };
 
-        let td = VThread::current().expect("Syscall invoked outside of a PS4 thread context");
-
         // Execute the handler.
+        let td = VThread::current().expect("syscall invoked outside of a PS4 thread context");
         let v = match handler(&td, i) {
             Ok(v) => v,
-            Err(e) => {
-                warn!(e, "Syscall {} failed", i.id);
-                return e.errno().get().into();
-            }
+            Err(e) => return e.errno().get().into(),
         };
 
         // Write the output.
@@ -93,3 +85,5 @@ impl Debug for Syscalls {
         f.debug_struct("Syscalls").finish()
     }
 }
+
+type Handler = Box<dyn Fn(&Arc<VThread>, &SysIn) -> Result<SysOut, SysErr> + Send + Sync>;
diff --git a/src/kernel/src/sysctl/mod.rs b/src/kernel/src/sysctl/mod.rs
index 80241ba60..9f3382d7a 100644
--- a/src/kernel/src/sysctl/mod.rs
+++ b/src/kernel/src/sysctl/mod.rs
@@ -109,7 +109,7 @@ impl Sysctl {
         ctl
     }
 
-    fn sys_sysctl(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_sysctl(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         // Get arguments.
         let name: *const i32 = i.args[0].into();
         let namelen: u32 = i.args[1].try_into().unwrap();
diff --git a/src/kernel/src/time/mod.rs b/src/kernel/src/time/mod.rs
index a2d1473d8..fd371608e 100644
--- a/src/kernel/src/time/mod.rs
+++ b/src/kernel/src/time/mod.rs
@@ -19,7 +19,7 @@ impl TimeManager {
         time
     }
 
-    fn sys_gettimeofday(self: &Arc<Self>, _: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_gettimeofday(self: &Arc<Self>, _: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let tv: *mut TimeVal = i.args[0].into();
         let tz: *mut TimeZone = i.args[1].into();
 
@@ -38,7 +38,7 @@ impl TimeManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_clock_gettime(self: &Arc<Self>, _: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_clock_gettime(self: &Arc<Self>, _: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let clock_id: ClockId = {
             let clock: i32 = i.args[0].try_into().unwrap();
 
@@ -74,7 +74,7 @@ impl TimeManager {
         Ok(SysOut::ZERO)
     }
 
-    fn sys_clock_getres(self: &Arc<Self>, _: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_clock_getres(self: &Arc<Self>, _: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let clock_id: ClockId = {
             let clock: i32 = i.args[0].try_into().unwrap();
 
diff --git a/src/kernel/src/umtx/mod.rs b/src/kernel/src/umtx/mod.rs
index 8b6190361..1d73de862 100644
--- a/src/kernel/src/umtx/mod.rs
+++ b/src/kernel/src/umtx/mod.rs
@@ -17,7 +17,7 @@ impl UmtxManager {
     }
 
     #[allow(non_snake_case)]
-    fn sys__umtx_op(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys__umtx_op(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let op: i32 = i.args[1].try_into().unwrap();
 
         if let Some(op) = OP_TABLE.get(op as usize) {
diff --git a/src/kernel/src/vm/mod.rs b/src/kernel/src/vm/mod.rs
index a2feca808..52e0ec020 100644
--- a/src/kernel/src/vm/mod.rs
+++ b/src/kernel/src/vm/mod.rs
@@ -526,18 +526,18 @@ impl Vm {
         })
     }
 
-    fn sys_sbrk(self: &Arc<Self>, _: &VThread, _: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_sbrk(self: &Arc<Self>, _: &Arc<VThread>, _: &SysIn) -> Result<SysOut, SysErr> {
         // Return EOPNOTSUPP (Not yet implemented syscall)
         Err(SysErr::Raw(EOPNOTSUPP))
     }
 
-    fn sys_sstk(self: &Arc<Self>, _: &VThread, _: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_sstk(self: &Arc<Self>, _: &Arc<VThread>, _: &SysIn) -> Result<SysOut, SysErr> {
         // Return EOPNOTSUPP (Not yet implemented syscall)
         Err(SysErr::Raw(EOPNOTSUPP))
     }
 
     #[allow(unused_variables)]
-    fn sys_munmap(self: &Arc<Self>, _: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_munmap(self: &Arc<Self>, _: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let addr: usize = i.args[0].into();
         let len: usize = i.args[1].into();
 
@@ -549,7 +549,7 @@ impl Vm {
         todo!()
     }
 
-    fn sys_mmap(self: &Arc<Self>, _: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_mmap(self: &Arc<Self>, _: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         // Get arguments.
         let addr: usize = i.args[0].into();
         let len: usize = i.args[1].into();
@@ -611,7 +611,7 @@ impl Vm {
         Ok(pages.into_raw().into())
     }
 
-    fn sys_batch_map(self: &Arc<Self>, td: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_batch_map(self: &Arc<Self>, td: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let dmem_fd: i32 = i.args[0].try_into().unwrap();
         let flags: MappingFlags = i.args[1].try_into().unwrap();
         let operations: *const BatchMapArg = i.args[2].into();
@@ -694,7 +694,7 @@ impl Vm {
         result.map(|_| SysOut::ZERO)
     }
 
-    fn sys_mname(self: &Arc<Self>, _: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_mname(self: &Arc<Self>, _: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let addr: usize = i.args[0].into();
         let len: usize = i.args[1].into();
         let name = unsafe { i.args[2].to_str(32)?.unwrap() };
@@ -718,7 +718,7 @@ impl Vm {
     }
 
     #[allow(unused_variables)]
-    fn sys_mmap_dmem(self: &Arc<Self>, _: &VThread, i: &SysIn) -> Result<SysOut, SysErr> {
+    fn sys_mmap_dmem(self: &Arc<Self>, _: &Arc<VThread>, i: &SysIn) -> Result<SysOut, SysErr> {
         let start_addr: usize = i.args[0].into();
         let len: usize = i.args[1].into();
         let mem_type: MemoryType = i.args[2].try_into().unwrap();