task: migrate all Task::block_on calls to task::block_on

Simple renamings... Further work is needed to make the system work.

Signed-off-by: greatbridf <greatbridf@icloud.com>

src/driver/ahci/mod.rs

@@ -6,6 +6,7 @@ use crate::{
         constants::{EINVAL, EIO},
         interrupt::register_irq_handler,
         pcie::{self, Header, PCIDevice, PCIDriver, PciError},
+        task::block_on,
     },
     prelude::*,
 };
@@ -13,7 +14,6 @@ use alloc::{format, sync::Arc};
 use control::AdapterControl;
 use defs::*;
 use eonix_mm::address::{AddrOps as _, PAddr};
-use eonix_runtime::task::Task;
 use eonix_sync::SpinIrq as _;
 use port::AdapterPort;
 
@@ -133,7 +133,7 @@ impl Device<'static> {
                     port,
                 )?;
 
-                Task::block_on(port.partprobe())?;
+                block_on(port.partprobe())?;
 
                 Ok(())
             })() {

src/driver/ahci/port.rs

@@ -9,11 +9,11 @@ use crate::kernel::block::{BlockDeviceRequest, BlockRequestQueue};
 use crate::kernel::constants::{EINVAL, EIO};
 use crate::kernel::mem::paging::Page;
 use crate::kernel::mem::AsMemoryBlock as _;
+use crate::kernel::task::block_on;
 use crate::prelude::*;
 use alloc::collections::vec_deque::VecDeque;
 use core::pin::pin;
 use eonix_mm::address::{Addr as _, PAddr};
-use eonix_runtime::task::Task;
 use eonix_sync::{SpinIrq as _, WaitList};
 
 /// An `AdapterPort` is an HBA device in AHCI mode.
@@ -156,7 +156,7 @@ impl AdapterPort<'_> {
             wait.as_mut().add_to_wait_list();
             drop(free_list);
 
-            Task::block_on(wait);
+            block_on(wait);
         }
     }
 
@@ -222,7 +222,7 @@ impl AdapterPort<'_> {
 
         self.stats.inc_cmd_sent();
 
-        if let Err(_) = Task::block_on(slot.wait_finish()) {
+        if let Err(_) = block_on(slot.wait_finish()) {
             self.stats.inc_cmd_error();
             return Err(EIO);
         };

src/driver/virtio/riscv64.rs

@@ -1,11 +1,13 @@
 use super::virtio_blk::HAL;
-use crate::kernel::block::{make_device, BlockDevice};
+use crate::kernel::{
+    block::{make_device, BlockDevice},
+    task::block_on,
+};
 use alloc::{sync::Arc, vec::Vec};
 use eonix_hal::arch_exported::fdt::FDT;
 use eonix_hal::mm::ArchPhysAccess;
 use eonix_log::{println_info, println_warn};
 use eonix_mm::address::{PAddr, PhysAccess};
-use eonix_runtime::task::Task;
 use eonix_sync::Spin;
 use virtio_drivers::{
     device::blk::VirtIOBlk,
@@ -47,7 +49,7 @@ pub fn init() {
                     )
                     .expect("Failed to register VirtIO Block device");
 
-                    Task::block_on(block_device.partprobe())
+                    block_on(block_device.partprobe())
                         .expect("Failed to probe partitions for VirtIO Block device");
 
                     disk_id += 1;

src/fs/ext4.rs

@@ -1,6 +1,7 @@
 use core::sync::atomic::{AtomicU32, AtomicU64, Ordering};
 
 use crate::kernel::mem::{PageCache, PageCacheBackend};
+use crate::kernel::task::block_on;
 use crate::{
     io::{Buffer, ByteBuffer},
     kernel::{
@@ -24,7 +25,6 @@ use alloc::{
     collections::btree_map::{BTreeMap, Entry},
     sync::Arc,
 };
-use eonix_runtime::task::Task;
 use eonix_sync::RwLock;
 use ext4_rs::{BlockDevice as Ext4BlockDeviceTrait, Ext4Error};
 use ext4_rs::{Errno, Ext4};
@@ -126,7 +126,7 @@ impl Ext4Fs {
         });
 
         let root_inode = {
-            let mut icache = Task::block_on(ext4fs.icache.write());
+            let mut icache = block_on(ext4fs.icache.write());
             let root_inode = ext4fs.inner.get_inode_ref(2);
 
             ext4fs.get_or_insert(
@@ -216,7 +216,7 @@ impl Inode for FileInode {
     }
 
     fn read(&self, buffer: &mut dyn Buffer, offset: usize) -> KResult<usize> {
-        Task::block_on(self.page_cache.read(buffer, offset))
+        block_on(self.page_cache.read(buffer, offset))
     }
 
     fn read_direct(&self, buffer: &mut dyn Buffer, offset: usize) -> KResult<usize> {
@@ -251,8 +251,7 @@ impl Inode for DirInode {
         };
 
         // Fast path: if the inode is already in the cache, return it.
-        if let Some(inode) = ext4fs.try_get(&Task::block_on(ext4fs.icache.read()), attr.ino as u64)
-        {
+        if let Some(inode) = ext4fs.try_get(&block_on(ext4fs.icache.read()), attr.ino as u64) {
             return Ok(Some(inode));
         }
 
@@ -261,7 +260,7 @@ impl Inode for DirInode {
         let real_perm = extra_perm | perm | perm >> 3 | perm >> 6;
 
         // Create a new inode based on the attributes.
-        let mut icache = Task::block_on(ext4fs.icache.write());
+        let mut icache = block_on(ext4fs.icache.write());
         let inode = ext4fs.get_or_insert(
             &mut icache,
             InodeData {

src/fs/fat32.rs

@@ -4,6 +4,7 @@ mod file;
 use crate::io::Stream;
 use crate::kernel::constants::EIO;
 use crate::kernel::mem::AsMemoryBlock;
+use crate::kernel::task::block_on;
 use crate::kernel::vfs::inode::WriteOffset;
 use crate::{
     io::{Buffer, ByteBuffer, UninitBuffer},
@@ -32,7 +33,6 @@ use alloc::{
 };
 use core::{ops::ControlFlow, sync::atomic::Ordering};
 use dir::Dirs as _;
-use eonix_runtime::task::Task;
 use eonix_sync::RwLock;
 use file::ClusterRead;
 
@@ -266,13 +266,13 @@ impl Inode for FileInode {
     }
 
     fn read(&self, buffer: &mut dyn Buffer, offset: usize) -> KResult<usize> {
-        Task::block_on(self.page_cache.read(buffer, offset))
+        block_on(self.page_cache.read(buffer, offset))
     }
 
     fn read_direct(&self, buffer: &mut dyn Buffer, offset: usize) -> KResult<usize> {
         let vfs = self.vfs.upgrade().ok_or(EIO)?;
         let vfs = vfs.as_any().downcast_ref::<FatFs>().unwrap();
-        let fat = Task::block_on(vfs.fat.read());
+        let fat = block_on(vfs.fat.read());
 
         if self.size.load(Ordering::Relaxed) as usize == 0 {
             return Ok(0);
@@ -354,7 +354,7 @@ impl Inode for DirInode {
     fn lookup(&self, dentry: &Arc<Dentry>) -> KResult<Option<Arc<dyn Inode>>> {
         let vfs = self.vfs.upgrade().ok_or(EIO)?;
         let vfs = vfs.as_any().downcast_ref::<FatFs>().unwrap();
-        let fat = Task::block_on(vfs.fat.read());
+        let fat = block_on(vfs.fat.read());
 
         let mut entries = ClusterIterator::new(fat.as_ref(), self.ino as ClusterNo)
             .read(vfs, 0)
@@ -385,7 +385,7 @@ impl Inode for DirInode {
     ) -> KResult<usize> {
         let vfs = self.vfs.upgrade().ok_or(EIO)?;
         let vfs = vfs.as_any().downcast_ref::<FatFs>().unwrap();
-        let fat = Task::block_on(vfs.fat.read());
+        let fat = block_on(vfs.fat.read());
 
         let cluster_iter = ClusterIterator::new(fat.as_ref(), self.ino as ClusterNo)
             .read(vfs, offset)

src/fs/procfs.rs

@@ -1,4 +1,5 @@
 use crate::kernel::constants::{EACCES, ENOTDIR};
+use crate::kernel::task::block_on;
 use crate::kernel::timer::Instant;
 use crate::{
     io::Buffer,
@@ -17,7 +18,6 @@ use crate::{
 };
 use alloc::sync::{Arc, Weak};
 use core::{ops::ControlFlow, sync::atomic::Ordering};
-use eonix_runtime::task::Task;
 use eonix_sync::{AsProof as _, AsProofMut as _, LazyLock, Locked};
 use itertools::Itertools;
 
@@ -134,7 +134,7 @@ impl DirInode {
 
 impl Inode for DirInode {
     fn lookup(&self, dentry: &Arc<Dentry>) -> KResult<Option<Arc<dyn Inode>>> {
-        let lock = Task::block_on(self.rwsem.read());
+        let lock = block_on(self.rwsem.read());
         Ok(self
             .entries
             .access(lock.prove())
@@ -147,7 +147,7 @@ impl Inode for DirInode {
         offset: usize,
         callback: &mut dyn FnMut(&[u8], Ino) -> KResult<ControlFlow<(), ()>>,
     ) -> KResult<usize> {
-        let lock = Task::block_on(self.rwsem.read());
+        let lock = block_on(self.rwsem.read());
         self.entries
             .access(lock.prove())
             .iter()
@@ -234,7 +234,7 @@ pub fn creat(
     let inode = FileInode::new(ino, Arc::downgrade(&fs), file);
 
     {
-        let lock = Task::block_on(parent.idata.rwsem.write());
+        let lock = block_on(parent.idata.rwsem.write());
         parent
             .entries
             .access_mut(lock.prove_mut())
@@ -258,7 +258,7 @@ pub fn mkdir(parent: &ProcFsNode, name: &[u8]) -> KResult<ProcFsNode> {
 
     parent
         .entries
-        .access_mut(Task::block_on(inode.rwsem.write()).prove_mut())
+        .access_mut(block_on(inode.rwsem.write()).prove_mut())
         .push((Arc::from(name), ProcFsNode::Dir(inode.clone())));
 
     Ok(ProcFsNode::Dir(inode))

src/fs/tmpfs.rs

@@ -1,6 +1,7 @@
 use crate::io::Stream;
 use crate::kernel::constants::{EEXIST, EINVAL, EIO, EISDIR, ENOENT, ENOSYS, ENOTDIR};
 use crate::kernel::mem::{CachePage, PageCache, PageCacheBackend};
+use crate::kernel::task::block_on;
 use crate::kernel::timer::Instant;
 use crate::kernel::vfs::inode::InodeData;
 use crate::kernel::vfs::inode::RenameData;
@@ -21,7 +22,6 @@ use alloc::sync::{Arc, Weak};
 use core::fmt::Debug;
 use core::{ops::ControlFlow, sync::atomic::Ordering};
 use eonix_mm::paging::PAGE_SIZE;
-use eonix_runtime::task::Task;
 use eonix_sync::{AsProof as _, AsProofMut as _, Locked, Mutex, ProofMut};
 use itertools::Itertools;
 
@@ -138,7 +138,7 @@ impl Inode for DirectoryInode {
         offset: usize,
         callback: &mut dyn FnMut(&[u8], Ino) -> KResult<ControlFlow<(), ()>>,
     ) -> KResult<usize> {
-        let lock = Task::block_on(self.rwsem.read());
+        let lock = block_on(self.rwsem.read());
         self.entries
             .access(lock.prove())
             .iter()
@@ -153,7 +153,7 @@ impl Inode for DirectoryInode {
         let vfs = acquire(&self.vfs)?;
         let vfs = astmp(&vfs);
 
-        let rwsem = Task::block_on(self.rwsem.write());
+        let rwsem = block_on(self.rwsem.write());
 
         let ino = vfs.assign_ino();
         let file = FileInode::new(ino, self.vfs.clone(), 0, mode);
@@ -170,7 +170,7 @@ impl Inode for DirectoryInode {
         let vfs = acquire(&self.vfs)?;
         let vfs = astmp(&vfs);
 
-        let rwsem = Task::block_on(self.rwsem.write());
+        let rwsem = block_on(self.rwsem.write());
 
         let ino = vfs.assign_ino();
         let file = NodeInode::new(
@@ -188,7 +188,7 @@ impl Inode for DirectoryInode {
         let vfs = acquire(&self.vfs)?;
         let vfs = astmp(&vfs);
 
-        let rwsem = Task::block_on(self.rwsem.write());
+        let rwsem = block_on(self.rwsem.write());
 
         let ino = vfs.assign_ino();
         let file = SymlinkInode::new(ino, self.vfs.clone(), target.into());
@@ -201,7 +201,7 @@ impl Inode for DirectoryInode {
         let vfs = acquire(&self.vfs)?;
         let vfs = astmp(&vfs);
 
-        let rwsem = Task::block_on(self.rwsem.write());
+        let rwsem = block_on(self.rwsem.write());
 
         let ino = vfs.assign_ino();
         let newdir = DirectoryInode::new(ino, self.vfs.clone(), mode);
@@ -213,11 +213,11 @@ impl Inode for DirectoryInode {
     fn unlink(&self, at: &Arc<Dentry>) -> KResult<()> {
         let _vfs = acquire(&self.vfs)?;
 
-        let dir_lock = Task::block_on(self.rwsem.write());
+        let dir_lock = block_on(self.rwsem.write());
 
         let file = at.get_inode()?;
         let filename = at.get_name();
-        let file_lock = Task::block_on(file.rwsem.write());
+        let file_lock = block_on(file.rwsem.write());
 
         let entries = self.entries.access_mut(dir_lock.prove_mut());
 
@@ -240,7 +240,7 @@ impl Inode for DirectoryInode {
 
     fn chmod(&self, mode: Mode) -> KResult<()> {
         let _vfs = acquire(&self.vfs)?;
-        let _lock = Task::block_on(self.rwsem.write());
+        let _lock = block_on(self.rwsem.write());
 
         // SAFETY: `rwsem` has done the synchronization
         let old = self.mode.load(Ordering::Relaxed);
@@ -271,7 +271,7 @@ impl Inode for DirectoryInode {
             .downcast_ref::<TmpFs>()
             .expect("vfs must be a TmpFs");
 
-        let _rename_lock = Task::block_on(vfs.rename_lock.lock());
+        let _rename_lock = block_on(vfs.rename_lock.lock());
 
         let old_file = old_dentry.get_inode()?;
         let new_file = new_dentry.get_inode();
@@ -284,7 +284,7 @@ impl Inode for DirectoryInode {
         if same_parent {
             // Same directory rename
             // Remove from old location and add to new location
-            let parent_lock = Task::block_on(self.rwsem.write());
+            let parent_lock = block_on(self.rwsem.write());
             let entries = self.entries.access_mut(parent_lock.prove_mut());
 
             fn rename_old(
@@ -328,7 +328,7 @@ impl Inode for DirectoryInode {
             if let Some(new_idx) = new_entry_idx {
                 // Replace existing file (i.e. rename the old and unlink the new)
                 let new_file = new_file.unwrap();
-                let _new_file_lock = Task::block_on(new_file.rwsem.write());
+                let _new_file_lock = block_on(new_file.rwsem.write());
 
                 // SAFETY: `new_file_lock` has done the synchronization
                 if new_file.mode.load(Ordering::Relaxed) & S_IFDIR != 0 {
@@ -364,8 +364,8 @@ impl Inode for DirectoryInode {
                 .downcast_ref::<DirectoryInode>()
                 .expect("new parent must be a DirectoryInode");
 
-            let old_parent_lock = Task::block_on(self.rwsem.write());
-            let new_parent_lock = Task::block_on(new_parent_inode.rwsem.write());
+            let old_parent_lock = block_on(self.rwsem.write());
+            let new_parent_lock = block_on(new_parent_inode.rwsem.write());
 
             let old_ino = old_file.ino;
             let new_ino = new_file.as_ref().ok().map(|f| f.ino);
@@ -391,7 +391,7 @@ impl Inode for DirectoryInode {
             if has_new {
                 // Replace existing file (i.e. move the old and unlink the new)
                 let new_file = new_file.unwrap();
-                let new_file_lock = Task::block_on(new_file.rwsem.write());
+                let new_file_lock = block_on(new_file.rwsem.write());
 
                 if old_file.mode.load(Ordering::Relaxed) & S_IFDIR != 0
                     && new_file.mode.load(Ordering::Relaxed) & S_IFDIR == 0
@@ -424,7 +424,7 @@ impl Inode for DirectoryInode {
             *old_file.ctime.lock() = now;
         }
 
-        Task::block_on(dcache::d_exchange(old_dentry, new_dentry));
+        block_on(dcache::d_exchange(old_dentry, new_dentry));
 
         Ok(())
     }
@@ -511,13 +511,13 @@ impl Inode for FileInode {
     }
 
     fn read(&self, buffer: &mut dyn Buffer, offset: usize) -> KResult<usize> {
-        let lock = Task::block_on(self.rwsem.write());
-        Task::block_on(self.pages.read(buffer, offset))
+        let _lock = block_on(self.rwsem.write());
+        block_on(self.pages.read(buffer, offset))
     }
 
     fn write(&self, stream: &mut dyn Stream, offset: WriteOffset) -> KResult<usize> {
         // TODO: We don't need that strong guarantee, find some way to avoid locks
-        let lock = Task::block_on(self.rwsem.write());
+        let _lock = block_on(self.rwsem.write());
 
         let mut store_new_end = None;
         let offset = match offset {
@@ -530,7 +530,7 @@ impl Inode for FileInode {
             }
         };
 
-        let wrote = Task::block_on(self.pages.write(stream, offset))?;
+        let wrote = block_on(self.pages.write(stream, offset))?;
         let cursor_end = offset + wrote;
 
         if let Some(store_end) = store_new_end {
@@ -545,8 +545,8 @@ impl Inode for FileInode {
     }
 
     fn truncate(&self, length: usize) -> KResult<()> {
-        let lock = Task::block_on(self.rwsem.write());
-        Task::block_on(self.pages.resize(length))?;
+        let _lock = block_on(self.rwsem.write());
+        block_on(self.pages.resize(length))?;
         self.size.store(length as u64, Ordering::Relaxed);
         *self.mtime.lock() = Instant::now();
         Ok(())
@@ -554,7 +554,7 @@ impl Inode for FileInode {
 
     fn chmod(&self, mode: Mode) -> KResult<()> {
         let _vfs = acquire(&self.vfs)?;
-        let _lock = Task::block_on(self.rwsem.write());
+        let _lock = block_on(self.rwsem.write());
 
         // SAFETY: `rwsem` has done the synchronization
         let old = self.mode.load(Ordering::Relaxed);

src/kernel/chardev.rs

@@ -2,7 +2,7 @@ use super::{
     block::make_device,
     console::get_console,
     constants::{EEXIST, EIO},
-    task::{ProcessList, Thread},
+    task::{block_on, ProcessList, Thread},
     terminal::Terminal,
     vfs::{
         file::{File, FileType, TerminalFile},
@@ -18,7 +18,6 @@ use alloc::{
     collections::btree_map::{BTreeMap, Entry},
     sync::Arc,
 };
-use eonix_runtime::task::Task;
 use eonix_sync::AsProof as _;
 use posix_types::open::OpenFlags;
 
@@ -43,7 +42,7 @@ static CHAR_DEVICES: Spin<BTreeMap<DevId, Arc<CharDevice>>> = Spin::new(BTreeMap
 impl CharDevice {
     pub fn read(&self, buffer: &mut dyn Buffer) -> KResult<usize> {
         match &self.device {
-            CharDeviceType::Terminal(terminal) => Task::block_on(terminal.read(buffer)),
+            CharDeviceType::Terminal(terminal) => block_on(terminal.read(buffer)),
             CharDeviceType::Virtual(device) => device.read(buffer),
         }
     }
@@ -75,13 +74,13 @@ impl CharDevice {
     pub fn open(self: &Arc<Self>, flags: OpenFlags) -> KResult<Arc<File>> {
         Ok(match &self.device {
             CharDeviceType::Terminal(terminal) => {
-                let procs = Task::block_on(ProcessList::get().read());
+                let procs = block_on(ProcessList::get().read());
                 let current = Thread::current();
                 let session = current.process.session(procs.prove());
                 // We only set the control terminal if the process is the session leader.
                 if session.sid == Thread::current().process.pid {
                     // Silently fail if we can't set the control terminal.
-                    dont_check!(Task::block_on(session.set_control_terminal(
+                    dont_check!(block_on(session.set_control_terminal(
                         &terminal,
                         false,
                         procs.prove()
@@ -123,7 +122,7 @@ struct ConsoleDevice;
 impl VirtualCharDevice for ConsoleDevice {
     fn read(&self, buffer: &mut dyn Buffer) -> KResult<usize> {
         let console_terminal = get_console().ok_or(EIO)?;
-        Task::block_on(console_terminal.read(buffer))
+        block_on(console_terminal.read(buffer))
     }
 
     fn write(&self, stream: &mut dyn Stream) -> KResult<usize> {

src/kernel/mem/mm_area.rs

@@ -2,6 +2,7 @@ use super::mm_list::EMPTY_PAGE;
 use super::paging::AllocZeroed as _;
 use super::{AsMemoryBlock, Mapping, Page, Permission};
 use crate::kernel::constants::EINVAL;
+use crate::kernel::task::block_on;
 use crate::prelude::KResult;
 use core::borrow::Borrow;
 use core::cell::UnsafeCell;
@@ -9,7 +10,6 @@ use core::cmp;
 use eonix_mm::address::{AddrOps as _, VAddr, VRange};
 use eonix_mm::page_table::{PageAttribute, RawAttribute, PTE};
 use eonix_mm::paging::{PAGE_SIZE, PFN};
-use eonix_runtime::task::Task;
 
 #[derive(Debug)]
 pub struct MMArea {
@@ -209,7 +209,7 @@ impl MMArea {
         }
 
         if attr.contains(PageAttribute::MAPPED) {
-            Task::block_on(self.handle_mmap(&mut pfn, &mut attr, offset, write))?;
+            block_on(self.handle_mmap(&mut pfn, &mut attr, offset, write))?;
         }
 
         attr.insert(PageAttribute::ACCESSED);

src/kernel/mem/mm_list.rs

@@ -7,6 +7,7 @@ use super::paging::AllocZeroed as _;
 use super::{AsMemoryBlock, MMArea, Page};
 use crate::kernel::constants::{EEXIST, EFAULT, EINVAL, ENOMEM};
 use crate::kernel::mem::page_alloc::RawPagePtr;
+use crate::kernel::task::block_on;
 use crate::{prelude::*, sync::ArcSwap};
 use alloc::collections::btree_set::BTreeSet;
 use core::fmt;
@@ -23,7 +24,6 @@ use eonix_mm::{
     page_table::{PageTable, RawAttribute, PTE},
     paging::PAGE_SIZE,
 };
-use eonix_runtime::task::Task;
 use eonix_sync::{LazyLock, Mutex};
 
 pub use mapping::{FileMapping, Mapping};
@@ -507,7 +507,7 @@ impl MMList {
         const VDSO_SIZE: usize = 0x1000;
 
         let inner = self.inner.borrow();
-        let inner = Task::block_on(inner.lock());
+        let inner = block_on(inner.lock());
 
         let mut pte_iter = inner
             .page_table
@@ -538,7 +538,7 @@ impl MMList {
         is_shared: bool,
     ) -> KResult<VAddr> {
         let inner = self.inner.borrow();
-        let mut inner = Task::block_on(inner.lock());
+        let mut inner = block_on(inner.lock());
 
         if hint == VAddr::NULL {
             let at = inner.find_available(hint, len).ok_or(ENOMEM)?;
@@ -565,14 +565,14 @@ impl MMList {
         permission: Permission,
         is_shared: bool,
     ) -> KResult<VAddr> {
-        Task::block_on(self.inner.borrow().lock())
+        block_on(self.inner.borrow().lock())
             .mmap(at, len, mapping.clone(), permission, is_shared)
             .map(|_| at)
     }
 
     pub fn set_break(&self, pos: Option<VAddr>) -> VAddr {
         let inner = self.inner.borrow();
-        let mut inner = Task::block_on(inner.lock());
+        let mut inner = block_on(inner.lock());
 
         // SAFETY: `set_break` is only called in syscalls, where program break should be valid.
         assert!(inner.break_start.is_some() && inner.break_pos.is_some());
@@ -631,7 +631,7 @@ impl MMList {
     /// This should be called only **once** for every thread.
     pub fn register_break(&self, start: VAddr) {
         let inner = self.inner.borrow();
-        let mut inner = Task::block_on(inner.lock());
+        let mut inner = block_on(inner.lock());
         assert!(inner.break_start.is_none() && inner.break_pos.is_none());
 
         inner.break_start = Some(start.into());
@@ -651,7 +651,7 @@ impl MMList {
         }
 
         let inner = self.inner.borrow();
-        let inner = Task::block_on(inner.lock());
+        let inner = block_on(inner.lock());
 
         let mut offset = 0;
         let mut remaining = len;

src/kernel/mem/mm_list/page_fault.rs

@@ -1,10 +1,9 @@
 use super::{MMList, VAddr};
-use crate::kernel::task::Thread;
+use crate::kernel::task::{block_on, Thread};
 use eonix_hal::mm::flush_tlb;
 use eonix_hal::traits::fault::PageFaultErrorCode;
 use eonix_mm::address::{Addr as _, AddrOps as _, VRange};
 use eonix_mm::paging::PAGE_SIZE;
-use eonix_runtime::task::Task;
 use posix_types::signal::Signal;
 
 #[repr(C)]
@@ -149,7 +148,7 @@ pub fn handle_kernel_page_fault(
 
     let mms = &Thread::current().process.mm_list;
     let inner = mms.inner.borrow();
-    let inner = Task::block_on(inner.lock());
+    let inner = block_on(inner.lock());
 
     let area = match inner.areas.get(&VRange::from(addr)) {
         Some(area) => area,

src/kernel/syscall/file_rw.rs

@@ -1,11 +1,9 @@
-use core::time::Duration;
-
 use super::FromSyscallArg;
 use crate::io::IntoStream;
 use crate::kernel::constants::{
     EBADF, EFAULT, EINVAL, ENOENT, ENOSYS, ENOTDIR, SEEK_CUR, SEEK_END, SEEK_SET, S_IFBLK, S_IFCHR,
 };
-use crate::kernel::task::Thread;
+use crate::kernel::task::{block_on, Thread};
 use crate::kernel::timer::sleep;
 use crate::kernel::vfs::filearray::FD;
 use crate::{
@@ -24,7 +22,7 @@ use crate::{
     prelude::*,
 };
 use alloc::sync::Arc;
-use eonix_runtime::task::Task;
+use core::time::Duration;
 use posix_types::ctypes::{Long, PtrT};
 use posix_types::namei::RenameFlags;
 use posix_types::open::{AtFlags, OpenFlags};
@@ -77,14 +75,14 @@ fn dentry_from(
 fn read(fd: FD, buffer: *mut u8, bufsize: usize) -> KResult<usize> {
     let mut buffer = UserBuffer::new(buffer, bufsize)?;
 
-    Task::block_on(thread.files.get(fd).ok_or(EBADF)?.read(&mut buffer, None))
+    block_on(thread.files.get(fd).ok_or(EBADF)?.read(&mut buffer, None))
 }
 
 #[eonix_macros::define_syscall(SYS_PREAD64)]
 fn pread64(fd: FD, buffer: *mut u8, bufsize: usize, offset: usize) -> KResult<usize> {
     let mut buffer = UserBuffer::new(buffer, bufsize)?;
 
-    Task::block_on(
+    block_on(
         thread
             .files
             .get(fd)
@@ -98,7 +96,7 @@ fn write(fd: FD, buffer: *const u8, count: usize) -> KResult<usize> {
     let buffer = CheckedUserPointer::new(buffer, count)?;
     let mut stream = buffer.into_stream();
 
-    Task::block_on(thread.files.get(fd).ok_or(EBADF)?.write(&mut stream, None))
+    block_on(thread.files.get(fd).ok_or(EBADF)?.write(&mut stream, None))
 }
 
 #[eonix_macros::define_syscall(SYS_PWRITE64)]
@@ -106,7 +104,7 @@ fn pwrite64(fd: FD, buffer: *const u8, count: usize, offset: usize) -> KResult<u
     let buffer = CheckedUserPointer::new(buffer, count)?;
     let mut stream = buffer.into_stream();
 
-    Task::block_on(
+    block_on(
         thread
             .files
             .get(fd)
@@ -390,7 +388,7 @@ fn readv(fd: FD, iov_user: *const IoVec, iovcnt: u32) -> KResult<usize> {
     let mut tot = 0usize;
     for mut buffer in iov_buffers.into_iter() {
         // TODO!!!: `readv`
-        let nread = Task::block_on(file.read(&mut buffer, None))?;
+        let nread = block_on(file.read(&mut buffer, None))?;
         tot += nread;
 
         if nread != buffer.total() {
@@ -426,7 +424,7 @@ fn writev(fd: FD, iov_user: *const IoVec, iovcnt: u32) -> KResult<usize> {
 
     let mut tot = 0usize;
     for mut stream in iov_streams.into_iter() {
-        let nread = Task::block_on(file.write(&mut stream, None))?;
+        let nread = block_on(file.write(&mut stream, None))?;
         tot += nread;
 
         if nread == 0 || !stream.is_drained() {
@@ -477,7 +475,7 @@ fn sendfile64(out_fd: FD, in_fd: FD, offset: *mut u8, count: usize) -> KResult<u
         unimplemented!("sendfile64 with offset");
     }
 
-    Task::block_on(in_file.sendfile(&out_file, count))
+    block_on(in_file.sendfile(&out_file, count))
 }
 
 #[eonix_macros::define_syscall(SYS_IOCTL)]
@@ -513,7 +511,7 @@ fn do_poll(thread: &Thread, fds: *mut UserPollFd, nfds: u32, _timeout: u32) -> K
             let mut fd = fds.read()?;
 
             let file = thread.files.get(fd.fd).ok_or(EBADF)?;
-            fd.revents = Task::block_on(file.poll(PollEvent::from_bits_retain(fd.events)))?.bits();
+            fd.revents = block_on(file.poll(PollEvent::from_bits_retain(fd.events)))?.bits();
 
             fds.write(fd)?;
             Ok(1)
@@ -550,11 +548,11 @@ fn pselect6(
     }
 
     let timeout = UserPointerMut::new(timeout)?;
-    
+
     // Read here to check for invalid pointers.
     let _timeout_value = timeout.read()?;
 
-    Task::block_on(sleep(Duration::from_millis(10)));
+    block_on(sleep(Duration::from_millis(10)));
 
     timeout.write(TimeSpec {
         tv_sec: 0,

src/kernel/syscall/mm.rs

@@ -2,7 +2,7 @@ use super::FromSyscallArg;
 use crate::fs::shm::{gen_shm_id, ShmFlags, IPC_PRIVATE, SHM_MANAGER};
 use crate::kernel::constants::{EBADF, EEXIST, EINVAL, ENOENT};
 use crate::kernel::mem::FileMapping;
-use crate::kernel::task::Thread;
+use crate::kernel::task::{block_on, Thread};
 use crate::kernel::vfs::filearray::FD;
 use crate::{
     kernel::{
@@ -14,7 +14,6 @@ use crate::{
 use align_ext::AlignExt;
 use eonix_mm::address::{Addr as _, AddrOps as _, VAddr};
 use eonix_mm::paging::PAGE_SIZE;
-use eonix_runtime::task::Task;
 use posix_types::syscall_no::*;
 
 impl FromSyscallArg for UserMmapProtocol {
@@ -67,11 +66,8 @@ fn do_mmap2(
             Mapping::Anonymous
         } else {
             // The mode is unimportant here, since we are checking prot in mm_area.
-            let shared_area = Task::block_on(SHM_MANAGER.lock()).create_shared_area(
-                len,
-                thread.process.pid,
-                0x777,
-            );
+            let shared_area =
+                block_on(SHM_MANAGER.lock()).create_shared_area(len, thread.process.pid, 0x777);
             Mapping::File(FileMapping::new(shared_area.area.clone(), 0, len))
         }
     } else {
@@ -94,7 +90,7 @@ fn do_mmap2(
     // TODO!!!: If we are doing mmap's in 32-bit mode, we should check whether
     //          `addr` is above user reachable memory.
     let addr = if flags.contains(UserMmapFlags::MAP_FIXED) {
-        Task::block_on(mm_list.unmap(addr, len));
+        block_on(mm_list.unmap(addr, len));
         mm_list.mmap_fixed(addr, len, mapping, permission, is_shared)
     } else {
         mm_list.mmap_hint(addr, len, mapping, permission, is_shared)
@@ -137,7 +133,7 @@ fn munmap(addr: usize, len: usize) -> KResult<usize> {
     }
 
     let len = len.align_up(PAGE_SIZE);
-    Task::block_on(thread.process.mm_list.unmap(addr, len)).map(|_| 0)
+    block_on(thread.process.mm_list.unmap(addr, len)).map(|_| 0)
 }
 
 #[eonix_macros::define_syscall(SYS_BRK)]
@@ -160,7 +156,7 @@ fn mprotect(addr: usize, len: usize, prot: UserMmapProtocol) -> KResult<()> {
 
     let len = len.align_up(PAGE_SIZE);
 
-    Task::block_on(thread.process.mm_list.protect(
+    block_on(thread.process.mm_list.protect(
         addr,
         len,
         Permission {
@@ -175,7 +171,7 @@ fn mprotect(addr: usize, len: usize, prot: UserMmapProtocol) -> KResult<()> {
 fn shmget(key: usize, size: usize, shmflg: u32) -> KResult<u32> {
     let size = size.align_up(PAGE_SIZE);
 
-    let mut shm_manager = Task::block_on(SHM_MANAGER.lock());
+    let mut shm_manager = block_on(SHM_MANAGER.lock());
     let shmid = gen_shm_id(key)?;
 
     let mode = shmflg & 0o777;
@@ -207,7 +203,7 @@ fn shmget(key: usize, size: usize, shmflg: u32) -> KResult<u32> {
 #[eonix_macros::define_syscall(SYS_SHMAT)]
 fn shmat(shmid: u32, addr: usize, shmflg: u32) -> KResult<usize> {
     let mm_list = &thread.process.mm_list;
-    let shm_manager = Task::block_on(SHM_MANAGER.lock());
+    let shm_manager = block_on(SHM_MANAGER.lock());
     let shm_area = shm_manager.get(shmid).ok_or(EINVAL)?;
 
     let mode = shmflg & 0o777;
@@ -256,7 +252,7 @@ fn shmdt(addr: usize) -> KResult<usize> {
     let size = *shm_areas.get(&addr).ok_or(EINVAL)?;
     shm_areas.remove(&addr);
     drop(shm_areas);
-    return Task::block_on(thread.process.mm_list.unmap(addr, size)).map(|_| 0);
+    return block_on(thread.process.mm_list.unmap(addr, size)).map(|_| 0);
 }
 
 #[eonix_macros::define_syscall(SYS_SHMCTL)]

src/kernel/syscall/procops.rs

@@ -8,8 +8,8 @@ use crate::kernel::constants::{
 };
 use crate::kernel::mem::PageBuffer;
 use crate::kernel::task::{
-    do_clone, futex_wait, futex_wake, yield_now, FutexFlags, FutexOp, ProcessList, ProgramLoader,
-    RobustListHead, SignalAction, Thread, WaitId, WaitType,
+    block_on, do_clone, futex_wait, futex_wake, yield_now, FutexFlags, FutexOp, ProcessList,
+    ProgramLoader, RobustListHead, SignalAction, Thread, WaitId, WaitType,
 };
 use crate::kernel::task::{parse_futexop, CloneArgs};
 use crate::kernel::timer::sleep;
@@ -27,7 +27,6 @@ use eonix_hal::processor::UserTLS;
 use eonix_hal::traits::trap::RawTrapContext;
 use eonix_hal::trap::TrapContext;
 use eonix_mm::address::{Addr as _, VAddr};
-use eonix_runtime::task::Task;
 use eonix_sync::AsProof as _;
 use posix_types::ctypes::PtrT;
 use posix_types::signal::{SigAction, SigInfo, SigSet, Signal};
@@ -59,7 +58,7 @@ fn nanosleep(req: *const (u32, u32), rem: *mut (u32, u32)) -> KResult<usize> {
     };
 
     let duration = Duration::from_secs(req.0 as u64) + Duration::from_nanos(req.1 as u64);
-    Task::block_on(sleep(duration));
+    block_on(sleep(duration));
 
     if let Some(rem) = rem {
         rem.write((0, 0))?;
@@ -90,7 +89,7 @@ fn clock_nanosleep(
     };
 
     let duration = Duration::from_secs(req.0 as u64) + Duration::from_nanos(req.1 as u64);
-    Task::block_on(sleep(duration));
+    block_on(sleep(duration));
 
     if let Some(rem) = rem {
         rem.write((0, 0))?;
@@ -212,7 +211,7 @@ fn execve(exec: *const u8, argv: *const PtrT, envp: *const PtrT) -> KResult<Sysc
         ProgramLoader::parse(&thread.fs_context, exec, dentry.clone(), argv, envp)?.load()?;
 
     if let Some(robust_list) = thread.get_robust_list() {
-        let _ = Task::block_on(robust_list.wake_all());
+        let _ = block_on(robust_list.wake_all());
         thread.set_robust_list(None);
     }
 
@@ -239,8 +238,8 @@ fn execve(exec: *const u8, argv: *const PtrT, envp: *const PtrT) -> KResult<Sysc
 #[eonix_macros::define_syscall(SYS_EXIT)]
 fn exit(status: u32) -> SyscallNoReturn {
     unsafe {
-        let mut procs = Task::block_on(ProcessList::get().write());
-        Task::block_on(procs.do_exit(&thread, WaitType::Exited(status), false));
+        let mut procs = block_on(ProcessList::get().write());
+        block_on(procs.do_exit(&thread, WaitType::Exited(status), false));
     }
 
     SyscallNoReturn
@@ -249,8 +248,8 @@ fn exit(status: u32) -> SyscallNoReturn {
 #[eonix_macros::define_syscall(SYS_EXIT_GROUP)]
 fn exit_group(status: u32) -> SyscallNoReturn {
     unsafe {
-        let mut procs = Task::block_on(ProcessList::get().write());
-        Task::block_on(procs.do_exit(&thread, WaitType::Exited(status), true));
+        let mut procs = block_on(ProcessList::get().write());
+        block_on(procs.do_exit(&thread, WaitType::Exited(status), true));
     }
 
     SyscallNoReturn
@@ -278,7 +277,7 @@ fn do_waitid(
         Some(options) => options,
     };
 
-    let Some(wait_object) = Task::block_on(thread.process.wait(
+    let Some(wait_object) = block_on(thread.process.wait(
         wait_id,
         options.contains(UserWaitOptions::WNOHANG),
         options.contains(UserWaitOptions::WUNTRACED),
@@ -377,7 +376,7 @@ fn getsid(pid: u32) -> KResult<u32> {
     if pid == 0 {
         Ok(thread.process.session_rcu().sid)
     } else {
-        let procs = Task::block_on(ProcessList::get().read());
+        let procs = block_on(ProcessList::get().read());
         procs
             .try_find_process(pid)
             .map(|proc| proc.session(procs.prove()).sid)
@@ -390,7 +389,7 @@ fn getpgid(pid: u32) -> KResult<u32> {
     if pid == 0 {
         Ok(thread.process.pgroup_rcu().pgid)
     } else {
-        let procs = Task::block_on(ProcessList::get().read());
+        let procs = block_on(ProcessList::get().read());
         procs
             .try_find_process(pid)
             .map(|proc| proc.pgroup(procs.prove()).pgid)
@@ -476,7 +475,7 @@ fn getrandom(buf: *mut u8, buflen: usize, _flags: u32) -> isize {
 
 #[eonix_macros::define_syscall(SYS_SCHED_YIELD)]
 fn sched_yield() -> KResult<()> {
-    Task::block_on(yield_now());
+    block_on(yield_now());
     Ok(())
 }
 
@@ -572,7 +571,7 @@ fn prctl(option: u32, arg2: usize) -> KResult<()> {
 
 #[eonix_macros::define_syscall(SYS_KILL)]
 fn kill(pid: i32, sig: u32) -> KResult<()> {
-    let procs = Task::block_on(ProcessList::get().read());
+    let procs = block_on(ProcessList::get().read());
     match pid {
         // Send signal to every process for which the calling process has
         // permission to send signals.
@@ -599,7 +598,7 @@ fn kill(pid: i32, sig: u32) -> KResult<()> {
 
 #[eonix_macros::define_syscall(SYS_TKILL)]
 fn tkill(tid: u32, sig: u32) -> KResult<()> {
-    Task::block_on(ProcessList::get().read())
+    block_on(ProcessList::get().read())
         .try_find_thread(tid)
         .ok_or(ESRCH)?
         .raise(Signal::try_from_raw(sig)?);
@@ -608,7 +607,7 @@ fn tkill(tid: u32, sig: u32) -> KResult<()> {
 
 #[eonix_macros::define_syscall(SYS_TGKILL)]
 fn tgkill(tgid: u32, tid: u32, sig: u32) -> KResult<()> {
-    let procs = Task::block_on(ProcessList::get().read());
+    let procs = block_on(ProcessList::get().read());
 
     let thread_to_kill = procs.try_find_thread(tid).ok_or(ESRCH)?;
     if thread_to_kill.process.pid != tgid {
@@ -867,11 +866,11 @@ fn futex(
 
     match futex_op {
         FutexOp::FUTEX_WAIT => {
-            Task::block_on(futex_wait(uaddr, pid, val as u32, None))?;
+            block_on(futex_wait(uaddr, pid, val as u32, None))?;
             return Ok(0);
         }
         FutexOp::FUTEX_WAKE => {
-            return Task::block_on(futex_wake(uaddr, pid, val as u32));
+            return block_on(futex_wake(uaddr, pid, val as u32));
         }
         FutexOp::FUTEX_REQUEUE => {
             todo!()
@@ -906,7 +905,7 @@ fn rt_sigreturn() -> KResult<SyscallNoReturn> {
                 "`rt_sigreturn` failed in thread {} with error {err}!",
                 thread.tid
             );
-            Task::block_on(thread.force_kill(Signal::SIGSEGV));
+            block_on(thread.force_kill(Signal::SIGSEGV));
         })?;
 
     Ok(SyscallNoReturn)
@@ -927,7 +926,7 @@ fn sigreturn() -> KResult<SyscallNoReturn> {
                 "`sigreturn` failed in thread {} with error {err}!",
                 thread.tid
             );
-            Task::block_on(thread.force_kill(Signal::SIGSEGV));
+            block_on(thread.force_kill(Signal::SIGSEGV));
         })?;
 
     Ok(SyscallNoReturn)

src/kernel/task/process.rs

@@ -1,3 +1,4 @@
+use super::block_on;
 use super::{
     process_group::ProcessGroupBuilder, signal::RaiseResult, thread::ThreadBuilder, ProcessGroup,
     ProcessList, Session, Thread,
@@ -17,7 +18,6 @@ use alloc::{
 };
 use core::sync::atomic::{AtomicU32, Ordering};
 use eonix_mm::address::VAddr;
-use eonix_runtime::task::Task;
 use eonix_sync::{
     AsProof as _, AsProofMut as _, Locked, Proof, ProofMut, RwLockReadGuard, SpinGuard,
     UnlockableGuard as _, UnlockedGuard as _,
@@ -134,7 +134,7 @@ impl WaitId {
         } else if id == -1 {
             WaitId::Any
         } else if id == 0 {
-            let procs = Task::block_on(ProcessList::get().read());
+            let procs = block_on(ProcessList::get().read());
             WaitId::Pgid(thread.process.pgroup(procs.prove()).pgid)
         } else {
             WaitId::Pid(id.cast_unsigned())
@@ -208,9 +208,9 @@ impl ProcessBuilder {
 
     pub fn clone_from(mut self, process: Arc<Process>, clone_args: &CloneArgs) -> Self {
         let mm_list = if clone_args.flags.contains(CloneFlags::CLONE_VM) {
-            Task::block_on(process.mm_list.new_shared())
+            block_on(process.mm_list.new_shared())
         } else {
-            Task::block_on(process.mm_list.new_cloned())
+            block_on(process.mm_list.new_cloned())
         };
 
         if let Some(exit_signal) = clone_args.exit_signal {
@@ -396,7 +396,7 @@ impl Process {
 
     /// Create a new session for the process.
     pub fn setsid(self: &Arc<Self>) -> KResult<u32> {
-        let mut process_list = Task::block_on(ProcessList::get().write());
+        let mut process_list = block_on(ProcessList::get().write());
         // If there exists a session that has the same sid as our pid, we can't create a new
         // session. The standard says that we should create a new process group and be the
         // only process in the new process group and session.
@@ -474,7 +474,7 @@ impl Process {
     /// This function should be called on the process that issued the syscall in order to do
     /// permission checks.
     pub fn setpgid(self: &Arc<Self>, pid: u32, pgid: u32) -> KResult<()> {
-        let mut procs = Task::block_on(ProcessList::get().write());
+        let mut procs = block_on(ProcessList::get().write());
         // We may set pgid of either the calling process or a child process.
         if pid == self.pid {
             self.do_setpgid(pgid, &mut procs)
@@ -609,7 +609,7 @@ impl Entry<'_, '_, '_> {
                 WaitId::Any => true,
                 WaitId::Pid(pid) => item.pid == pid,
                 WaitId::Pgid(pgid) => {
-                    let procs = Task::block_on(ProcessList::get().read());
+                    let procs = block_on(ProcessList::get().read());
                     if let Some(process) = procs.try_find_process(item.pid) {
                         return process.pgroup(procs.prove()).pgid == pgid;
                     }

src/kernel/terminal.rs

@@ -1,5 +1,5 @@
 use super::{
-    task::{ProcessList, Session, Thread},
+    task::{block_on, ProcessList, Session, Thread},
     user::{UserPointer, UserPointerMut},
 };
 use crate::kernel::constants::{EINTR, ENOTTY, EPERM};
@@ -10,7 +10,6 @@ use alloc::{
 };
 use bitflags::bitflags;
 use eonix_log::ConsoleWrite;
-use eonix_runtime::task::Task;
 use eonix_sync::{AsProof as _, Mutex};
 use posix_types::signal::Signal;
 
@@ -449,7 +448,7 @@ impl Terminal {
 
     fn signal(&self, inner: &mut TerminalInner, signal: Signal) {
         if let Some(session) = inner.session.upgrade() {
-            Task::block_on(session.raise_foreground(signal));
+            block_on(session.raise_foreground(signal));
         }
         if !inner.termio.noflsh() {
             self.clear_read_buffer(inner);

src/kernel/vfs/dentry/dcache.rs

@@ -1,5 +1,6 @@
 use super::{Dentry, Inode};
 use crate::kernel::constants::ENOENT;
+use crate::kernel::task::block_on;
 use crate::rcu::RCUPointer;
 use crate::{
     kernel::vfs::{s_isdir, s_islnk},
@@ -8,7 +9,6 @@ use crate::{
 };
 use alloc::sync::Arc;
 use core::sync::atomic::Ordering;
-use eonix_runtime::task::Task;
 use eonix_sync::Mutex;
 
 const DCACHE_HASH_BITS: u32 = 8;
@@ -42,7 +42,7 @@ pub fn d_find_fast(dentry: &Dentry) -> Option<Arc<Dentry>> {
 ///
 /// Silently fail without any side effects
 pub fn d_try_revalidate(dentry: &Arc<Dentry>) {
-    let _lock = Task::block_on(D_EXCHANGE_LOCK.lock());
+    let _lock = block_on(D_EXCHANGE_LOCK.lock());
 
     (|| -> KResult<()> {
         let parent = dentry.parent().get_inode()?;

src/kernel/vfs/file.rs

@@ -8,7 +8,7 @@ use crate::{
     kernel::{
         constants::{TCGETS, TCSETS, TIOCGPGRP, TIOCGWINSZ, TIOCSPGRP},
         mem::{paging::Page, AsMemoryBlock as _},
-        task::Thread,
+        task::{block_on, Thread},
         terminal::{Terminal, TerminalIORequest},
         user::{UserPointer, UserPointerMut},
         vfs::inode::Inode,
@@ -29,7 +29,6 @@ use core::{
     ops::{ControlFlow, Deref},
     sync::atomic::{AtomicU32, Ordering},
 };
-use eonix_runtime::task::Task;
 use eonix_sync::Mutex;
 use posix_types::{open::OpenFlags, signal::Signal, stat::StatX};
 
@@ -159,7 +158,7 @@ impl Pipe {
     }
 
     fn close_read(&self) {
-        let mut inner = Task::block_on(self.inner.lock());
+        let mut inner = block_on(self.inner.lock());
         if inner.read_closed {
             return;
         }
@@ -169,7 +168,7 @@ impl Pipe {
     }
 
     fn close_write(&self) {
-        let mut inner = Task::block_on(self.inner.lock());
+        let mut inner = block_on(self.inner.lock());
         if inner.write_closed {
             return;
         }
@@ -318,7 +317,7 @@ impl InodeFile {
     }
 
     fn seek(&self, option: SeekOption) -> KResult<usize> {
-        let mut cursor = Task::block_on(self.cursor.lock());
+        let mut cursor = block_on(self.cursor.lock());
 
         let new_cursor = match option {
             SeekOption::Current(off) => cursor.checked_add_signed(off).ok_or(EOVERFLOW)?,
@@ -339,7 +338,7 @@ impl InodeFile {
             return Err(EBADF);
         }
 
-        let mut cursor = Task::block_on(self.cursor.lock());
+        let mut cursor = block_on(self.cursor.lock());
 
         if self.append {
             let nwrote = self.dentry.write(stream, WriteOffset::End(&mut cursor))?;
@@ -367,7 +366,7 @@ impl InodeFile {
             let nread = self.dentry.read(buffer, offset)?;
             nread
         } else {
-            let mut cursor = Task::block_on(self.cursor.lock());
+            let mut cursor = block_on(self.cursor.lock());
 
             let nread = self.dentry.read(buffer, *cursor)?;
 
@@ -379,7 +378,7 @@ impl InodeFile {
     }
 
     fn getdents64(&self, buffer: &mut dyn Buffer) -> KResult<()> {
-        let mut cursor = Task::block_on(self.cursor.lock());
+        let mut cursor = block_on(self.cursor.lock());
 
         let nread = self.dentry.readdir(*cursor, |filename, ino| {
             // Filename length + 1 for padding '\0'
@@ -409,7 +408,7 @@ impl InodeFile {
     }
 
     fn getdents(&self, buffer: &mut dyn Buffer) -> KResult<()> {
-        let mut cursor = Task::block_on(self.cursor.lock());
+        let mut cursor = block_on(self.cursor.lock());
 
         let nread = self.dentry.readdir(*cursor, |filename, ino| {
             // + 1 for filename length padding '\0', + 1 for d_type.
@@ -466,7 +465,7 @@ impl TerminalFile {
     }
 
     fn ioctl(&self, request: usize, arg3: usize) -> KResult<()> {
-        Task::block_on(self.terminal.ioctl(match request as u32 {
+        block_on(self.terminal.ioctl(match request as u32 {
             TCGETS => TerminalIORequest::GetTermios(UserPointerMut::new_vaddr(arg3)?),
             TCSETS => TerminalIORequest::SetTermios(UserPointer::new_vaddr(arg3)?),
             TIOCGPGRP => TerminalIORequest::GetProcessGroup(UserPointerMut::new_vaddr(arg3)?),

src/kernel/vfs/filearray.rs

@@ -29,7 +29,7 @@ use itertools::{
 };
 use posix_types::open::{FDFlags, OpenFlags};
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct FD(u32);
 
 #[derive(Clone)]
@@ -323,6 +323,15 @@ impl FD {
     pub const AT_FDCWD: FD = FD(-100i32 as u32);
 }
 
+impl core::fmt::Debug for FD {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            &Self::AT_FDCWD => f.write_str("FD(AT_FDCWD)"),
+            FD(no) => f.debug_tuple("FD").field(&no).finish(),
+        }
+    }
+}
+
 impl FromSyscallArg for FD {
     fn from_arg(value: usize) -> Self {
         Self(value as u32)

src/kernel/vfs/inode.rs

@@ -5,6 +5,7 @@ use crate::kernel::constants::{
     STATX_MODE, STATX_MTIME, STATX_NLINK, STATX_SIZE, STATX_TYPE, STATX_UID, S_IFDIR, S_IFMT,
 };
 use crate::kernel::mem::PageCache;
+use crate::kernel::task::block_on;
 use crate::kernel::timer::Instant;
 use crate::{io::Buffer, prelude::*};
 use alloc::sync::{Arc, Weak};
@@ -14,7 +15,6 @@ use core::{
     ptr::addr_of_mut,
     sync::atomic::{AtomicU32, AtomicU64, Ordering},
 };
-use eonix_runtime::task::Task;
 use eonix_sync::RwLock;
 use posix_types::stat::StatX;
 
@@ -280,7 +280,7 @@ pub trait Inode: Send + Sync + InodeInner + Any {
         f(
             uninit_mut.as_mut_ptr(),
             // SAFETY: `idata` is initialized and we will never move the lock.
-            &Task::block_on(unsafe { idata.assume_init_ref() }.rwsem.read()),
+            &block_on(unsafe { idata.assume_init_ref() }.rwsem.read()),
         );
 
         // Safety: `uninit` is initialized