someboot 0.2.1

Sparreal OS kernel
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

#[derive(Clone, Copy)]
enum CpuIdSource {
    Unknown,
    Acpi,
    Fdt,
    Default,
    Done,
}

pub(super) fn cpu_id_list() -> impl Iterator<Item = usize> {
    CpuIdIter::new()
}

struct CpuIdIter {
    source: CpuIdSource,
    next_index: usize,
    pending_first: Option<usize>,
    default_emitted: bool,
}

impl CpuIdIter {
    fn new() -> Self {
        Self {
            source: CpuIdSource::Unknown,
            next_index: 0,
            pending_first: None,
            default_emitted: false,
        }
    }

    fn select_source(&mut self) {
        if let Some(mut iter) = crate::acpi::cpu_id_list()
            && let Some(first) = iter.next()
        {
            self.source = CpuIdSource::Acpi;
            self.pending_first = Some(first);
            self.next_index = 1;
            return;
        }

        if let Some(mut iter) = crate::fdt::cpu_id_list()
            && let Some(first) = iter.next()
        {
            self.source = CpuIdSource::Fdt;
            self.pending_first = Some(first);
            self.next_index = 1;
            return;
        }

        self.source = CpuIdSource::Default;
    }

    fn next_from_acpi(&mut self) -> Option<usize> {
        if let Some(id) = self.pending_first.take() {
            return Some(id);
        }

        let mut iter = crate::acpi::cpu_id_list()?;
        let id = iter.nth(self.next_index)?;
        self.next_index += 1;
        Some(id)
    }

    fn next_from_fdt(&mut self) -> Option<usize> {
        if let Some(id) = self.pending_first.take() {
            return Some(id);
        }

        let mut iter = crate::fdt::cpu_id_list()?;
        let id = iter.nth(self.next_index)?;
        self.next_index += 1;
        Some(id)
    }
}

impl Iterator for CpuIdIter {
    type Item = usize;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            match self.source {
                CpuIdSource::Unknown => self.select_source(),
                CpuIdSource::Acpi => {
                    if let Some(id) = self.next_from_acpi() {
                        return Some(id);
                    }
                    self.source = CpuIdSource::Done;
                }
                CpuIdSource::Fdt => {
                    if let Some(id) = self.next_from_fdt() {
                        return Some(id);
                    }
                    self.source = CpuIdSource::Done;
                }
                CpuIdSource::Default => {
                    if self.default_emitted {
                        self.source = CpuIdSource::Done;
                    } else {
                        self.default_emitted = true;
                        return Some(0);
                    }
                }
                CpuIdSource::Done => return None,
            }
        }
    }
}