page-table 0.0.6

Encapsulation of the page table for common architectures.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use super::{Pos, Visitor};
use crate::{PageTable, Pte, VmMeta, PPN};
use core::{fmt, marker::PhantomData, ptr::NonNull};

/// 页表格式化器。
///
/// 为了遍历，需要知道在当前地址空间访问物理页的方法。
pub struct PageTableFormatter<Meta: VmMeta, F: Fn(PPN<Meta>) -> NonNull<Pte<Meta>>> {
    /// 根页表。
    pub pt: PageTable<Meta>,
    /// 物理页转换为指针。
    pub f: F,
}

impl<Meta: VmMeta, F: Fn(PPN<Meta>) -> NonNull<Pte<Meta>>> fmt::Debug
    for PageTableFormatter<Meta, F>
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.pt.walk(
            Pos {
                vpn: self.pt.base,
                level: 0,
            },
            &mut FmtVisitor {
                f,
                t: &self.f,
                max_level: self.pt.level,
                level: self.pt.level + 1,
                _phantom: PhantomData,
            },
        );
        Ok(())
    }
}

struct FmtVisitor<'f1, 'f2, Meta: VmMeta, T: Fn(PPN<Meta>) -> NonNull<Pte<Meta>>> {
    f: &'f1 mut fmt::Formatter<'f2>,
    t: T,
    max_level: usize,
    level: usize,
    _phantom: PhantomData<Meta>,
}

impl<'f1, 'f2, Meta: VmMeta, T: Fn(PPN<Meta>) -> NonNull<Pte<Meta>>> FmtVisitor<'f1, 'f2, Meta, T> {
    /// 打印一个物理页号。
    fn ppn(&mut self, ppn: PPN<Meta>, level: usize) {
        if level >= self.level {
            writeln!(self.f).unwrap();
            for _ in level..self.max_level {
                for _ in 0..18 {
                    write!(self.f, " ").unwrap();
                }
                write!(self.f, " - ").unwrap();
            }
        }
        write!(self.f, "{:#018x}", ppn.val()).unwrap();
    }

    /// 打印一个页表项。
    fn pte(&mut self, pte: Pte<Meta>, pos: Pos<Meta>) {
        // 打印映射的虚址范围和自定义的权限位
        let range = pos.vpn.vaddr_range(pos.level);
        write!(
            self.f,
            " {:#018x}..{:#018x} (",
            range.start.val(),
            range.end.val()
        )
        .unwrap();
        Meta::fmt_flags(self.f, pte.flags().val()).unwrap();
        write!(self.f, ")").unwrap();
        self.level = pos.level;
    }
}

impl<'f1, 'f2, Meta: VmMeta, T: Fn(PPN<Meta>) -> NonNull<Pte<Meta>>> Visitor<Meta>
    for FmtVisitor<'f1, 'f2, Meta, T>
{
    #[inline]
    fn meet(
        &mut self,
        level: usize,
        pte: Pte<Meta>,
        _target: Pos<Meta>,
    ) -> Option<core::ptr::NonNull<Pte<Meta>>> {
        self.ppn(pte.ppn(), level);
        write!(self.f, " - ").unwrap();
        self.level = level;
        Some((self.t)(pte.ppn()))
    }

    #[inline]
    fn block(&mut self, level: usize, pte: Pte<Meta>, target: Pos<Meta>) -> Pos<Meta> {
        if pte.is_valid() {
            self.ppn(pte.ppn(), level);
            // 打印一些横线
            for _ in 0..level {
                write!(self.f, " - ").unwrap();
                for _ in 0..18 {
                    write!(self.f, "-").unwrap();
                }
            }
            // 打印映射的虚址范围和自定义的权限位
            self.pte(pte, Pos { level, ..target });
        }
        Pos {
            level: 0,
            ..Pos::new(target.vpn, level).next()
        }
    }

    fn arrive(&mut self, pte: Pte<Meta>, target: Pos<Meta>) -> Pos<Meta> {
        // 如果有效，要打印信息
        if pte.is_valid() {
            self.ppn(pte.ppn(), 0);
            self.pte(pte, target);
        }
        target.next()
    }
}