Function get_page_chunk

kernel/src/memory.rs:551–599

Remove a page chunk from a page table Doesn't free any of the pages Returns physical address and level of the page table that it points to

(
    level_4_physaddr: u64,
    address: VirtAddr,
    take: bool
)

///
/// Returns physical address and level of the page table that it points to
pub fn get_page_chunk(
    level_4_physaddr: u64,
    address: VirtAddr,
    take: bool
) -> Result<(PhysAddr, u16), usize> {
        let memory_info = unsafe {MEMORY_INFO.as_mut().unwrap()};

    // Check that the p4 and p3 index is in range
    if usize::from(address.p4_index()) != MEMORY_CHUNK_L4_ENTRY {
        // Incorrect P4 entry
        return Err(syscalls::SYSCALL_ERROR_PARAM);
    }
    if (usize::from(address.p3_index()) < MEMORY_CHUNK_L3_FIRST) ||
        (usize::from(address.p3_index()) > MEMORY_CHUNK_L3_LAST) {
            // P3 out of range
            return Err(syscalls::SYSCALL_ERROR_PARAM);
        }

    // Follow page table addresses
    let l4_table: &PageTable = unsafe {
        & *(memory_info.physical_memory_offset
            + level_4_physaddr).as_mut_ptr()};
    let l4_entry = &l4_table[MEMORY_CHUNK_L4_ENTRY];

    if l4_entry.is_unused() {
        // No chunks allocated
        return Err(syscalls::SYSCALL_ERROR_MEMORY);
    }

    let l3_table: &mut PageTable = unsafe {
        &mut *(memory_info.physical_memory_offset
               + l4_entry.addr().as_u64()).as_mut_ptr()};
    let l3_entry = &mut l3_table[address.p3_index()];

    if l3_entry.is_unused() {
        // Not allocated => Double free?
        return Err(syscalls::SYSCALL_ERROR_DOUBLEFREE);
    }

    let physaddr = l3_entry.addr();

    if take {
        // Mark entry as empty
        l3_entry.set_unused();
    }

    // Return address of level 2 page table
    Ok((physaddr, 2))
}

/// Finds an available page chunk entry, stores the physical address
/// in the page table and returns the virtual address.