Function new_user_thread

kernel/src/process.rs:463–629

Create a new user thread # Arguments `bin` - ELF binary containing the program. Note: This must be accessible in the kernel page tables `params` - A collection of parameters. Used so that the calling site is clearer in what parameters are being set.

(
    bin: &[u8],
    params: Params
)

/// * `params` - A collection of parameters. Used so that the calling
///              site is clearer in what parameters are being set.
pub fn new_user_thread(
    bin: &[u8],
    params: Params
) -> Result<Box<Thread>, &'static str> {
    // Check the header
    const ELF_MAGIC: [u8; 4] = [0x7f, b'E', b'L', b'F'];

    if bin[0..4] != ELF_MAGIC {
        return Err("Expected ELF binary");
    }
    // Use the object crate to parse the ELF file
    // <https://crates.io/crates/object>
    if let Ok(obj) = object::File::parse(bin) {

        // Create a user pagetable with only kernel pages
        let (user_page_table_ptr, user_page_table_physaddr) =
            memory::create_new_user_pagetable();

        // Allocate user heap
        if memory::create_user_ondemand_pages(
            user_page_table_physaddr,
            VirtAddr::new(USER_HEAP_START),
            USER_HEAP_SIZE).is_err() {
            return Err("Couldn't allocate on-demand pages");
        }

        return with_pagetable(user_page_table_physaddr, || {

            let entry_point = obj.entry();

            for segment in obj.segments() {
                let segment_address = segment.address() as u64;

                let start_address = VirtAddr::new(segment_address);
                let end_address = start_address + segment.size() as u64;

                // Check if data is in allowed range
                if (start_address < VirtAddr::new(USER_CODE_START))
                    || (end_address >= VirtAddr::new(USER_CODE_END)) {
                        return Err("ELF segment outside allowed range");
                    }

                // Allocate memory in the pagetable
                if memory::allocate_pages(user_page_table_ptr,
                                          start_address,
                                          segment.size() as u64, // Size (bytes)
                                          PageTableFlags::PRESENT |
                                          PageTableFlags::WRITABLE |
                                          PageTableFlags::USER_ACCESSIBLE).is_err() {
                    return Err("Could not allocate memory");
                }
                memory::switch_to_pagetable(user_page_table_physaddr);

                if let Ok(data) = segment.data() {
                    if data.len() > segment.size() as usize {
                        return Err("ELF data length > segment size");
                    } else if data.len() > 0 {
                        // Copy data