Function new_kernel_thread

kernel/src/process.rs:362–420

Start a new kernel thread by adding it to the process table. This won't run immediately, but will run when the scheduler next switches to it. Inputs ------ function : fn() -> () The new thread entry point Returns ------- The TID of the new thread Note: returning Box to be scheduled leads to panic in VirtAddr::new(). Cause unknown, exposing memory/stack bug?

(
    function: fn()->(),
    mut handles: Vec<Arc<RwLock<Rendezvous>>>
)

/// exposing memory/stack bug?
///
pub fn new_kernel_thread(
    function: fn()->(),
    mut handles: Vec<Arc<RwLock<Rendezvous>>>
) -> u64 {

    // Create a new process table entry
    //
    // Note this is first created on the stack, then moved into a Box
    // on the heap.
    let new_thread = {
        // Allocate both "user" and kernel stacks in kernel memory
        let kernel_stack = Vec::with_capacity(KERNEL_STACK_SIZE + USER_STACK_SIZE);
        let kernel_stack_start = VirtAddr::from_ptr(kernel_stack.as_ptr());
        let kernel_stack_end = (kernel_stack_start + KERNEL_STACK_SIZE).as_u64();
        let user_stack_end = kernel_stack_end + (USER_STACK_SIZE as u64);

        Box::new(Thread {
            tid: unique_id(),
            process: Arc::new(RwLock::new(Process {
                page_table_physaddr: 0,
                // Wrap each handle in an Option
                handles:handles.drain(..)
                    .map(|h| Some(h)).collect(),
                // Empty set of mount paths
                mounts: vfs::VFS::new()
            })),
            page_table_physaddr: 0, // Don't need to switch PT
            kernel_stack,
            // Note that stacks move backwards, so SP points to the end
            kernel_stack_end,
            user_stack_end,
            // Push a Context struct on the kernel stack
            context: kernel_stack_end - INTERRUPT_CONTEXT_SIZE as u64,
        })
    };

    // Cast context address to Context struct
    let context = new_thread.context_mut();

    // Set the instruction pointer
    context.rip = function as usize;

    // Set flags
    context.rflags = 0x200;

    // Set segment selector flags
    let (code_selector, data_selector) = gdt::get_kernel_segments();
    context.cs = code_selector.0 as usize;
    context.ss = data_selector.0 as usize;

    // The kernel thread has its own stack
    // Note: Need to point to the end of the memory region
    //       because the stack moves down in memory
    context.rsp = new_thread.user_stack_end as usize;

    let tid = new_thread.tid;
    schedule_thread(new_thread);
    tid