zodiac 0.3.0

Rust OS framework that offers safe interfaces for kernel development
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
121

use core::ptr::addr_of;

use spin::Lazy;
use x86_64::VirtAddr;
use x86_64::instructions::segmentation::{CS, SS, Segment};
use x86_64::instructions::tables::load_tss;
use x86_64::structures::gdt::GlobalDescriptorTable;
use x86_64::structures::gdt::{Descriptor, SegmentSelector};
use x86_64::structures::tss::TaskStateSegment;

pub struct CpuInfo {
    gdt: GlobalDescriptorTable,
    tss: TaskStateSegment,
    selectors: Option<Selectors>,
}

impl Default for CpuInfo {
    fn default() -> Self {
        Self {
            gdt: GlobalDescriptorTable::new(),
            tss: TaskStateSegment::new(),
            selectors: None,
        }
    }
}

impl CpuInfo {
    pub fn tss_mut(&mut self) -> &mut TaskStateSegment {
        &mut self.tss
    }

    #[inline]
    pub fn set_ring0_rsp(&mut self, rsp: VirtAddr) {
        self.tss.privilege_stack_table[0] = rsp;
    }

    #[inline]
    pub fn get_ring0_rsp(&self) -> VirtAddr {
        self.tss.privilege_stack_table[0]
    }

    #[inline]
    pub fn set_ring3_rsp(&mut self, rsp: VirtAddr) {
        self.tss.privilege_stack_table[1] = rsp;
    }

    #[inline]
    pub fn get_ring3_rsp(&self) -> VirtAddr {
        self.tss.privilege_stack_table[1]
    }
}

impl CpuInfo {
    pub fn init(&mut self) {
        let (mut gdt, mut selectors) = COMMON_GDT.clone();

        let tss_ref = unsafe { &*addr_of!(self.tss) };
        let tss_selector = Some(gdt.append(Descriptor::tss_segment(tss_ref)));
        selectors.tss_selector = tss_selector;

        self.gdt = gdt;
        self.selectors = Some(selectors);

        let gdt_ptr: *const _ = &self.gdt;
        unsafe { (*gdt_ptr).load() }

        let selectors = &self.selectors.as_ref().unwrap();
        unsafe {
            CS::set_reg(selectors.code_selector);
            SS::set_reg(selectors.data_selector);
            load_tss(selectors.tss_selector.unwrap());
        }
    }

    pub fn kernel_code_selector(&self) -> usize {
        self.selectors.as_ref().unwrap().code_selector.0 as usize
    }

    pub fn kernel_data_selector(&self) -> usize {
        self.selectors.as_ref().unwrap().data_selector.0 as usize
    }

    pub fn user_code_selector(&self) -> usize {
        self.selectors.as_ref().unwrap().user_code_selector.0 as usize
    }

    pub fn user_data_selector(&self) -> usize {
        self.selectors.as_ref().unwrap().user_data_selector.0 as usize
    }
}

static COMMON_GDT: Lazy<(GlobalDescriptorTable, Selectors)> = Lazy::new(|| {
    let mut gdt = GlobalDescriptorTable::new();

    let code_selector = gdt.append(Descriptor::kernel_code_segment());
    let data_selector = gdt.append(Descriptor::kernel_data_segment());
    let user_data_selector = gdt.append(Descriptor::user_data_segment());
    let user_code_selector = gdt.append(Descriptor::user_code_segment());

    //log::info!("kernel code selector: {:x?}, kernel data selector: {:x?}", code_selector.0, data_selector.0);
    //log::info!("user code selector: {:x?}, user data selector: {:x?}", user_code_selector.0, user_data_selector.0);

    let selectors = Selectors {
        code_selector,
        data_selector,
        user_data_selector,
        user_code_selector,
        tss_selector: None,
    };

    (gdt, selectors)
});

#[derive(Clone)]
pub struct Selectors {
    code_selector: SegmentSelector,
    data_selector: SegmentSelector,
    user_code_selector: SegmentSelector,
    user_data_selector: SegmentSelector,
    tss_selector: Option<SegmentSelector>,
}