Function create_user_ondemand_pages

kernel/src/memory.rs:325–380

Create user-accessible pages, which are allocated on demand ie when written to. One frame is allocated, and made writable through the first page in the range. The other pages point to the same frame but are read-only. Writes to those frames trigger a page fault, and the handler allocates a frame. This allows large user heaps to be created without using a lot of memory. Inputs ------ size Size

(
    level_4_physaddr: u64,
    start_addr: VirtAddr,
    size: u64)

///   size   Size of memory region in bytes
///
pub fn create_user_ondemand_pages(
    level_4_physaddr: u64,
    start_addr: VirtAddr,
    size: u64)
    -> Result<(), MapToError<Size4KiB>> {

    let memory_info = unsafe {MEMORY_INFO.as_mut().unwrap()};
    let frame_allocator = &mut memory_info.frame_allocator;

    let l4_table: &mut PageTable = unsafe {
        &mut *(memory_info.physical_memory_offset
               + level_4_physaddr).as_mut_ptr()};

    let mut mapper = unsafe {
        OffsetPageTable::new(l4_table,
                             memory_info.physical_memory_offset)};

    let page_range = {
        let end_addr = start_addr + size - 1u64;
        let start_page = Page::containing_address(start_addr);
        let end_page = Page::containing_address(end_addr);
        Page::range_inclusive(start_page, end_page)
    };

    // Only allocating one frame
    let frame = frame_allocator
        .allocate_frame()
        .ok_or(MapToError::FrameAllocationFailed)?;

    for page in page_range {
        unsafe {
            mapper.map_to_with_table_flags(page,
                                           frame,
                                           // Page not writable
                                           PageTableFlags::PRESENT |
                                           PageTableFlags::USER_ACCESSIBLE,
                                           // Parent table flags include writable
                                           PageTableFlags::PRESENT |
                                           PageTableFlags::WRITABLE |
                                           PageTableFlags::USER_ACCESSIBLE,
                                           frame_allocator)?.flush()
        };
    }

    // Make one page writable, so this 'owns' the frame
    unsafe {
        mapper.update_flags(page_range.start,
                            PageTableFlags::PRESENT |
                            PageTableFlags::WRITABLE |
                            PageTableFlags::USER_ACCESSIBLE)
            .map_err(|_| MapToError::FrameAllocationFailed)?
            .flush(); // Update page table
    }

    Ok(())
}

/// Map a consecutive set of pages to a consecutive set of frames