# Компиляция, упаковка, преобразование формата, резервирование места
build: dependency
    @cargo build
    @echo Targets: $(patsubst $(SRC_DIR)/%.rs, %, $(SRC_FILES))
    @rm -rf $(OUT_DIR)
    @mkdir -p $(OUT_DIR)
    @cp $(BIN_FILES) $(OUT_DIR)
--> @dd if=/dev/zero of=$(OUT_DIR)/SWAP_FILE bs=1M count=16
    @rcore-fs-fuse --fs sfs $(IMG_FILE) $(OUT_DIR) zip
    @qemu-img convert -f raw $(IMG_FILE) -O qcow2 $(QCOW_FILE)
    @qemu-img resize $(QCOW_FILE) +1G

/// Подобно [`FrameTracker`], эквивалентно `Box<страница в файле замещения>`
///
/// Внутреннее сохранение индекса этой страницы в файле замещения
///
/// [`FrameTracker`]: crate::memory::frame::FrameTracker
#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Hash)]
pub struct SwapTracker(pub(super) usize);

impl SwapTracker {
    /// Из файла замещения выделяется новая страница
    pub fn new() -> MemoryResult<Self> {
        ...
    }

    /// Чтение данных страницы
    pub fn read(&self) -> [u8; PAGE_SIZE] {
        ...
    }

    /// Запись данных страницы
    pub fn write(&self, data: &[u8; PAGE_SIZE]) {
        ...
    }
}

impl Drop for SwapTracker {
    fn drop(&mut self) {
        ...
    }
}

/// Управление операциями замещения для сопоставленных страниц потока
pub trait Swapper {
    /// Создание нового распределителя с ограничением квоты
    fn new(quota: usize) -> Self;

    /// Достигнут ли предел квоты?
    fn full(&self) -> bool;

    /// Вытащить набор сопоставлений
    fn pop(&mut self) -> Option<(VirtualPageNumber, FrameTracker)>;

    /// Добавить набор сопоставлений (не вызывается при достижении предела квоты)
    fn push(&mut self, vpn: VirtualPageNumber, frame: FrameTracker);

    /// Сохранять только элементы, соответствующие определённому условию (используется для удаления диапазона виртуальных адресов)
    fn retain(&mut self, predicate: impl Fn(&VirtualPageNumber) -> bool);
}

/// Сопоставление памяти процесса
pub struct Mapping {
    /// Сохранить все используемые таблицы страниц
    page_tables: Vec<PageTableTracker>,
    /// Корневая таблица страниц физического номера страницы
    root_ppn: PhysicalPageNumber,
    /// Все сопоставления физических страниц
    mapped_pairs: SwapperImpl,
    /// Страницы, сохранённые в файле виртуальной памяти
    swapped_pages: HashMap<VirtualPageNumber, SwapTracker>,
}

impl Mapping {
    /// Обработка исключения нехватки страницы
    pub fn handle_page_fault(&mut self, stval: usize) -> MemoryResult<()> {
        let vpn = VirtualPageNumber::floor(stval.into());
        let swap_tracker = self
            .swapped_pages
            .remove(&vpn)
            .ok_or("stval page is not mapped")?;
        let page_data = swap_tracker.read();

        if self.mapped_pairs.full() {
            // Вытащить сопоставление
            let (popped_vpn, mut popped_frame) = self.mapped_pairs.pop().unwrap();
            // print!("{:x?} -> {:x?}", popped_vpn, vpn);
            // Обмен данными
            swap_tracker.write(&*popped_frame);
            (*popped_frame).copy_from_slice(&page_data);

... // Изменить отображение таблицы страниц
self.invalidate_one(popped_vpn)?;
self.remap_one(vpn, popped_frame.page_number())?;
// Обновить запись
self.mapped_pairs.push(vpn, popped_frame);
self.swapped_pages.insert(popped_vpn, swap_tracker);
} else {
// Если текущий лимит ещё не достигнут, можно продолжить распределение физических страниц. В настоящее время такая ситуация не возникает
// Добавить новое сопоставление
let mut frame = FRAME_ALLOCATOR.lock().alloc()?;
// Скопировать данные
(*frame).copy_from_slice(&page_data);
// Изменить сопоставление
self.remap_one(vpn, frame.page_number())?;
// Обновить запись
self.mapped_pairs.push(vpn, frame);
}
Ok(())
}

Затем, вызвав функцию выше при возникновении исключения отсутствия страницы, мы завершаем реализацию замены страницы.

```rust
/// Обработка исключения отсутствия страницы
///
/// todo: теоретически здесь необходимо определить тип доступа и сравнить его с флагами в таблице страниц
fn page_fault(context: &mut Context, stval: usize) -> Result<*mut Context, String> {
println!("page_fault");
let current_thread = PROCESSOR.lock().current_thread();
let memory_set = &mut current_thread.process.write().memory_set;
memory_set.mapping.handle_page_fault(stval)?;
memory_set.activate();
Ok(context)
}