Remove UserSpace abstraction from OSTD

kernel/src/process/clone.rs

@@ -2,12 +2,7 @@
 
 use core::{num::NonZeroU64, sync::atomic::Ordering};
 
-use ostd::{
-    cpu::UserContext,
-    sync::RwArc,
-    task::Task,
-    user::{UserContextApi, UserSpace},
-};
+use ostd::{cpu::UserContext, sync::RwArc, task::Task, user::UserContextApi};
 
 use super::{
     posix_thread::{AsPosixThread, PosixThreadBuilder, ThreadName},
@@ -230,18 +225,13 @@ fn clone_child_task(
     // clone fs
     let child_fs = clone_fs(posix_thread.fs(), clone_flags);
 
-    let child_root_vmar = process.root_vmar();
-    let child_user_space = {
-        let child_vm_space = child_root_vmar.vm_space().clone();
-        let child_cpu_context = clone_cpu_context(
-            parent_context,
-            clone_args.stack,
-            clone_args.stack_size,
-            clone_args.tls,
-            clone_flags,
-        );
-        Arc::new(UserSpace::new(child_vm_space, child_cpu_context))
-    };
+    let child_user_ctx = Arc::new(clone_user_ctx(
+        parent_context,
+        clone_args.stack,
+        clone_args.stack_size,
+        clone_args.tls,
+        clone_flags,
+    ));
 
     // Inherit sigmask from current thread
     let sig_mask = posix_thread.sig_mask().load(Ordering::Relaxed).into();
@@ -253,7 +243,7 @@ fn clone_child_task(
             Credentials::new_from(&credentials)
         };
 
-        let mut thread_builder = PosixThreadBuilder::new(child_tid, child_user_space, credentials)
+        let mut thread_builder = PosixThreadBuilder::new(child_tid, child_user_ctx, credentials)
             .process(posix_thread.weak_process())
             .sig_mask(sig_mask)
             .file_table(child_file_table)
@@ -297,20 +287,13 @@ fn clone_child_process(
     };
 
     // clone user space
-    let child_user_space = {
-        let child_cpu_context = clone_cpu_context(
-            parent_context,
-            clone_args.stack,
-            clone_args.stack_size,
-            clone_args.tls,
-            clone_flags,
-        );
-        let child_vm_space = {
-            let child_root_vmar = child_process_vm.root_vmar();
-            child_root_vmar.vm_space().clone()
-        };
-        Arc::new(UserSpace::new(child_vm_space, child_cpu_context))
-    };
+    let child_user_ctx = Arc::new(clone_user_ctx(
+        parent_context,
+        clone_args.stack,
+        clone_args.stack_size,
+        clone_args.tls,
+        clone_flags,
+    ));
 
     // clone file table
     let child_file_table = clone_files(&thread_local.file_table().borrow(), clone_flags);
@@ -342,7 +325,7 @@ fn clone_child_process(
                 Credentials::new_from(&credentials)
             };
 
-            PosixThreadBuilder::new(child_tid, child_user_space, credentials)
+            PosixThreadBuilder::new(child_tid, child_user_ctx, credentials)
                 .thread_name(Some(child_thread_name))
                 .sig_mask(child_sig_mask)
                 .file_table(child_file_table)
@@ -432,7 +415,7 @@ fn clone_vm(parent_process_vm: &ProcessVm, clone_flags: CloneFlags) -> Result<Pr
     }
 }
 
-fn clone_cpu_context(
+fn clone_user_ctx(
     parent_context: &UserContext,
     new_sp: u64,
     stack_size: Option<NonZeroU64>,

kernel/src/process/posix_thread/builder.rs

@@ -2,7 +2,11 @@
 
 #![expect(dead_code)]
 
-use ostd::{cpu::CpuSet, sync::RwArc, task::Task, user::UserSpace};
+use ostd::{
+    cpu::{CpuSet, UserContext},
+    sync::RwArc,
+    task::Task,
+};
 
 use super::{thread_table, PosixThread, ThreadLocal};
 use crate::{
@@ -22,7 +26,7 @@ use crate::{
 pub struct PosixThreadBuilder {
     // The essential part
     tid: Tid,
-    user_space: Arc<UserSpace>,
+    user_ctx: Arc<UserContext>,
     process: Weak<Process>,
     credentials: Credentials,
 
@@ -38,10 +42,10 @@ pub struct PosixThreadBuilder {
 }
 
 impl PosixThreadBuilder {
-    pub fn new(tid: Tid, user_space: Arc<UserSpace>, credentials: Credentials) -> Self {
+    pub fn new(tid: Tid, user_ctx: Arc<UserContext>, credentials: Credentials) -> Self {
         Self {
             tid,
-            user_space,
+            user_ctx,
             process: Weak::new(),
             credentials,
             thread_name: None,
@@ -98,7 +102,7 @@ impl PosixThreadBuilder {
     pub fn build(self) -> Arc<Task> {
         let Self {
             tid,
-            user_space,
+            user_ctx,
             process,
             credentials,
             thread_name,
@@ -148,7 +152,7 @@ impl PosixThreadBuilder {
             let thread_local = ThreadLocal::new(set_child_tid, clear_child_tid, file_table);
 
             thread_table::add_thread(tid, thread.clone());
-            task::create_new_user_task(user_space, thread, thread_local)
+            task::create_new_user_task(user_ctx, thread, thread_local)
         })
     }
 }

kernel/src/process/posix_thread/posix_thread_ext.rs

@@ -1,10 +1,6 @@
 // SPDX-License-Identifier: MPL-2.0
 
-use ostd::{
-    cpu::UserContext,
-    task::Task,
-    user::{UserContextApi, UserSpace},
-};
+use ostd::{cpu::UserContext, task::Task, user::UserContextApi};
 
 use super::{builder::PosixThreadBuilder, name::ThreadName, PosixThread};
 use crate::{
@@ -55,13 +51,11 @@ pub fn create_posix_task_from_executable(
         load_program_to_vm(process_vm, elf_file, argv, envp, &fs_resolver, 1)?
     };
 
-    let vm_space = process_vm.root_vmar().vm_space().clone();
-    let mut cpu_ctx = UserContext::default();
-    cpu_ctx.set_instruction_pointer(elf_load_info.entry_point() as _);
-    cpu_ctx.set_stack_pointer(elf_load_info.user_stack_top() as _);
-    let user_space = Arc::new(UserSpace::new(vm_space, cpu_ctx));
+    let mut user_ctx = UserContext::default();
+    user_ctx.set_instruction_pointer(elf_load_info.entry_point() as _);
+    user_ctx.set_stack_pointer(elf_load_info.user_stack_top() as _);
     let thread_name = Some(ThreadName::new_from_executable_path(executable_path)?);
-    let thread_builder = PosixThreadBuilder::new(tid, user_space, credentials)
+    let thread_builder = PosixThreadBuilder::new(tid, Arc::new(user_ctx), credentials)
         .thread_name(thread_name)
         .process(process)
         .fs(Arc::new(fs));

kernel/src/thread/task.rs

@@ -1,8 +1,9 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use ostd::{
+    cpu::UserContext,
     task::{Task, TaskOptions},
-    user::{ReturnReason, UserContextApi, UserMode, UserSpace},
+    user::{ReturnReason, UserContextApi, UserMode},
 };
 
 use super::{oops, Thread};
@@ -21,7 +22,7 @@ use crate::{
 
 /// create new task with userspace and parent process
 pub fn create_new_user_task(
-    user_space: Arc<UserSpace>,
+    user_ctx: Arc<UserContext>,
     thread_ref: Arc<Thread>,
     thread_local: ThreadLocal,
 ) -> Task {
@@ -32,10 +33,10 @@ pub fn create_new_user_task(
         let current_thread_local = current_task.as_thread_local().unwrap();
         let current_process = current_posix_thread.process();
 
-        let user_space = current_task
-            .user_space()
-            .expect("user task should have user space");
-        let mut user_mode = UserMode::new(user_space);
+        let user_ctx = current_task
+            .user_ctx()
+            .expect("user task should have user context");
+        let mut user_mode = UserMode::new(UserContext::clone(user_ctx));
         debug!(
             "[Task entry] rip = 0x{:x}",
             user_mode.context().instruction_pointer()
@@ -67,7 +68,7 @@ pub fn create_new_user_task(
             thread_local: current_thread_local,
             posix_thread: current_posix_thread,
             thread: current_thread.as_ref(),
-            task: current_task.as_ref(),
+            task: &current_task,
         };
 
         loop {
@@ -109,7 +110,7 @@ pub fn create_new_user_task(
     })
     .data(thread_ref)
     .local_data(thread_local)
-    .user_space(Some(user_space))
+    .user_ctx(Some(user_ctx))
     .build()
     .expect("spawn task failed")
 }

kernel/src/vm/vmar/mod.rs

@@ -306,7 +306,6 @@ impl Vmar_ {
     fn new_root() -> Arc<Self> {
         let vmar_inner = VmarInner::new();
         let mut vm_space = VmSpace::new();
-        vm_space.register_page_fault_handler(handle_page_fault_wrapper);
         Vmar_::new(vmar_inner, Arc::new(vm_space), 0, ROOT_VMAR_CAP_ADDR)
     }
 
@@ -431,7 +430,6 @@ impl Vmar_ {
         let new_vmar_ = {
             let vmar_inner = VmarInner::new();
             let mut new_space = VmSpace::new();
-            new_space.register_page_fault_handler(handle_page_fault_wrapper);
             Vmar_::new(vmar_inner, Arc::new(new_space), self.base, self.size)
         };