redox/kernel/context/memory.rs

use arch::externs::memset;
use arch::paging::{ActivePageTable, InactivePageTable, Page, PageIter, VirtualAddress};
use arch::paging::entry::{self, EntryFlags};
use arch::paging::temporary_page::TemporaryPage;

#[derive(Debug)]
pub struct Memory {
    start: VirtualAddress,
    size: usize,
    flags: EntryFlags
}

impl Memory {
    pub fn new(start: VirtualAddress, size: usize, flags: EntryFlags, flush: bool, clear: bool) -> Self {
        let mut memory = Memory {
            start: start,
            size: size,
            flags: flags
        };

        memory.map(flush, clear);

        memory
    }

    pub fn start_address(&self) -> VirtualAddress {
        self.start
    }

    pub fn size(&self) -> usize {
        self.size
    }

    pub fn flags(&self) -> EntryFlags {
        self.flags
    }

    pub fn pages(&self) -> PageIter {
        let start_page = Page::containing_address(self.start);
        let end_page = Page::containing_address(VirtualAddress::new(self.start.get() + self.size - 1));
        Page::range_inclusive(start_page, end_page)
    }

    fn map(&mut self, flush: bool, clear: bool) {
        let mut active_table = unsafe { ActivePageTable::new() };

        let mut flush_all = false;

        //TODO: Clear pages?
        for page in self.pages() {
            active_table.map(page, self.flags);

            if flush {
                //active_table.flush(page);
                flush_all = true;
            }
        }

        if flush_all {
            active_table.flush_all();
        }

        if clear {
            assert!(flush && self.flags.contains(entry::WRITABLE));
            unsafe { memset(self.start_address().get() as *mut u8, 0, self.size); }
        }
    }

    fn unmap(&mut self, flush: bool) {
        let mut active_table = unsafe { ActivePageTable::new() };

        let mut flush_all = false;

        for page in self.pages() {
            active_table.unmap(page);

            if flush {
                //active_table.flush(page);
                flush_all = true;
            }
        }

        if flush_all {
            active_table.flush_all();
        }
    }

    /// A complicated operation to move a piece of memory to a new page table
    /// It also allows for changing the address at the same time
    pub fn move_to(&mut self, new_start: VirtualAddress, new_table: &mut InactivePageTable, temporary_page: &mut TemporaryPage, flush: bool) {
        let mut active_table = unsafe { ActivePageTable::new() };

        let mut flush_all = false;

        for page in self.pages() {
            let frame = active_table.unmap_return(page);

            active_table.with(new_table, temporary_page, |mapper| {
                let new_page = Page::containing_address(VirtualAddress::new(page.start_address().get() - self.start.get() + new_start.get()));
                mapper.map_to(new_page, frame, self.flags);
            });

            if flush {
                //active_table.flush(page);
                flush_all = true;
            }
        }

        if flush_all {
            active_table.flush_all();
        }

        self.start = new_start;
    }

    pub fn remap(&mut self, new_flags: EntryFlags, flush: bool) {
        let mut active_table = unsafe { ActivePageTable::new() };

        let mut flush_all = false;

        for page in self.pages() {
            active_table.remap(page, new_flags);

            if flush {
                //active_table.flush(page);
                flush_all = true;
            }
        }

        if flush_all {
            active_table.flush_all();
        }

        self.flags = new_flags;
    }

    pub fn resize(&mut self, new_size: usize, flush: bool, clear: bool) {
        let mut active_table = unsafe { ActivePageTable::new() };

        //TODO: Calculate page changes to minimize operations
        if new_size > self.size {
            let mut flush_all = false;

            let start_page = Page::containing_address(VirtualAddress::new(self.start.get() + self.size));
            let end_page = Page::containing_address(VirtualAddress::new(self.start.get() + new_size - 1));
            for page in Page::range_inclusive(start_page, end_page) {
                if active_table.translate_page(page).is_none() {
                    active_table.map(page, self.flags);

                    if flush {
                        //active_table.flush(page);
                        flush_all = true;
                    }
                }
            }

            if flush_all {
                active_table.flush_all();
            }

            if clear {
                assert!(flush);
                unsafe { memset((self.start.get() + self.size) as *mut u8, 0, new_size - self.size); }
            }
        } else if new_size < self.size {
            let mut flush_all = false;

            let start_page = Page::containing_address(VirtualAddress::new(self.start.get() + new_size));
            let end_page = Page::containing_address(VirtualAddress::new(self.start.get() + self.size - 1));
            for page in Page::range_inclusive(start_page, end_page) {
                if active_table.translate_page(page).is_some() {
                    active_table.unmap(page);

                    if flush {
                        //active_table.flush(page);
                        flush_all = true;
                    }
                }
            }

            if flush_all {
                active_table.flush_all();
            }
        }

        self.size = new_size;
    }
}

impl Drop for Memory {
    fn drop(&mut self) {
        self.unmap(true);
    }
}