lambdaOS 0.1.0

A simple operating system written in Rust
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

unsafe fn disable() {
    asm!("cli");
}

unsafe fn enable() {
    asm!("sti");
}

/// Disable all interrupts and save the PIC masks
pub fn disable_interrupts() -> (u8, u8) {
    use device::pic::PICS;

    unsafe {
        disable();
    }

    let saved_masks: (u8, u8) = {
        let mask_pic0 = PICS.lock().pics[0].data.read();
        let mask_pic1 = PICS.lock().pics[1].data.read();

        (mask_pic0, mask_pic1)
    };

    PICS.lock().pics[0].data.write(0xff);
    PICS.lock().pics[1].data.write(0xff);

    saved_masks
}

/// Enable all interrupts
pub fn enable_interrupts() {
    use device::pic::PICS;

    // Ensure that PIC manipulation is not interrupted
    unsafe {
        disable();
    }

    {
        // Clear all interrupt masks
        PICS.lock().pics[0].data.write(0);
        PICS.lock().pics[1].data.write(0);
    }

    unsafe {
        enable();
    }
}

/// Restore interrupts to previous state
pub fn restore_interrupts(saved_masks: (u8, u8)) {
    use device::pic::PICS;

    // Ensure PIC manipulation is not interrupted
    unsafe {
        disable();
    }

    let (mask_pic0, mask_pic1) = saved_masks;

    PICS.lock().pics[0].data.write(mask_pic0);
    PICS.lock().pics[1].data.write(mask_pic1);

    unsafe {
        enable();
    }
}

// Stolen from Robert Gries.
// This function disables interrupts, allows a function to run without them enabled, and then
// reenables interrupts.
pub fn disable_interrupts_and_then<F, T>(f: F) -> T
where
    F: FnOnce() -> T,
{
    let saved_masks = disable_interrupts();

    let result: T = f();

    restore_interrupts(saved_masks);

    result
}