blob: a483a90eb5e9905ef5278fa71467b6a3679fee49 (
plain)
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
|
use crate::defs::*;
use crate::io::*;
use crate::machine::multiboot;
use core::ops::Range;
use linked_list_allocator::LockedHeap;
pub mod pma;
use lazy_static::lazy_static;
use spin::Mutex;
#[global_allocator]
static ALLOCATOR: LockedHeap = LockedHeap::empty();
/// half measure: simply initialize the linkedlist allocator
pub fn init() {
let mbi = multiboot::get_mb_info().unwrap();
let mmapinfo = unsafe { mbi.get_mmap() }.unwrap();
let buf_start = mmapinfo.mmap_addr;
let buf_len = mmapinfo.mmap_length;
let buf_end = buf_start + buf_len;
let mut curr = buf_start as u64;
// initialize the heap allocator with the largest physical memory block
let mut largest_phy_range: Option<Range<u64>> = None;
loop {
if curr >= buf_end as u64 {
break;
}
let mblock = unsafe { &*(curr as *const multiboot::MultibootMmap) };
curr += mblock.size as u64;
curr += 4;
if mblock.mtype != multiboot::MultibootMmap::MTYPE_RAM {
continue;
}
if mblock.get_end() <= unsafe { pmap_kernel_start() } {
continue;
}
// TODO early break if the array is already full
let mut r = mblock.get_range();
if r.contains(&unsafe { pmap_kernel_end() }) {
assert!(
r.contains(&unsafe { pmap_kernel_start() }),
"FATAL: kernel physical map cross physical blocks, how?"
);
r.start = unsafe { pmap_kernel_end() };
}
match largest_phy_range {
None => largest_phy_range = Some(r),
Some(ref lr) => {
if (r.end - r.start) > (lr.end - lr.start) {
largest_phy_range = Some(r);
}
}
}
}
let pr = &largest_phy_range.expect("Can't find any available physical block");
assert!((pr.end - pr.start) >= Mem::MIN_PHY_MEM, "TO LITTLE RAM ...");
// init heap allocator on id map
unsafe {
ALLOCATOR.lock().init(
P2V(pr.start).unwrap() as *mut u8,
(pr.end - pr.start) as usize,
);
}
println!(
"[init] mm: heap alloc initialized @ {:#X} - {:#X}",
P2V(pr.start).unwrap(),
P2V(pr.end).unwrap()
);
}
/// populate the physical frame pool. This conflicts with the kernel heap allocator (kmalloc),
/// which operates on the id map regions.
pub fn _init_pma() {
todo!()
}
|
