xref: /DragonOS/kernel/src/mm/allocator/bump.rs (revision 4b0170bd6bb374d0e9699a0076cc23b976ad6db7) 
1 /// @Auther: Kong
2 /// @Date: 2023-03-27 06:54:08
3 /// @FilePath: /DragonOS/kernel/src/mm/allocator/bump.rs
4 /// @Description: bump allocator线性分配器
5 use super::page_frame::{FrameAllocator, PageFrameCount, PageFrameUsage};
6 use crate::mm::{
7     allocator::page_frame::{PhysPageFrame, PhysPageFrameIter},
8     init::{mm_init_status, MMInitStatus},
9     memblock::mem_block_manager,
10     no_init::pseudo_map_phys,
11     page::PageMapper,
12     MemoryManagementArch, PageTableKind, PhysAddr, PhysMemoryArea,
13 };
14 use core::marker::PhantomData;
15 
16 /// 线性分配器
17 pub struct BumpAllocator<MMA> {
18     // 表示当前分配的物理内存的偏移量.
19     offset: usize,
20     // 一个占位类型，用于标记 A 类型在结构体中的存在。但是，它并不会占用任何内存空间，因为它的大小为 0。
21     phantom: PhantomData<MMA>,
22 }
23 
24 /// 为BumpAllocator实现FrameAllocator
25 impl<MMA: MemoryManagementArch> BumpAllocator<MMA> {
26     /// @brief: 创建一个线性分配器
27     /// @param Fareas 当前的内存区域
28     /// @param offset 当前的偏移量
29     /// @return 分配器本身
30     pub fn new(offset: usize) -> Self {
31         Self {
32             offset,
33             phantom: PhantomData,
34         }
35     }
36 
37     // @brief 获取当前分配的物理内存的偏移量
38     pub fn offset(&self) -> usize {
39         return self.offset;
40     }
41 
42     /// 返回剩余的尚未被分配的物理内存区域
43     ///
44     /// ## 返回值
45     ///
46     /// - `result_area`：剩余的尚未被分配的物理内存区域的数组
47     /// - `offset_aligned`：返回的第一个物理内存区域内，已经分配的偏移量(相对于物理内存区域的已对齐的起始地址)
48     pub fn remain_areas(&self, result_area: &mut [PhysMemoryArea]) -> Option<usize> {
49         let mut offset = self.offset();
50 
51         let iter = mem_block_manager().to_iter_available();
52 
53         let mut ret_offset_aligned = 0;
54 
55         let mut res_cnt = 0;
56 
57         let mut found_start = false;
58         // 遍历所有的物理内存区域
59         for area in iter {
60             if !found_start {
61                 // 将area的base地址与PAGE_SIZE对齐，对齐时向上取整
62                 // let area_base = (area.base.data() + MMA::PAGE_SHIFT) & !(MMA::PAGE_SHIFT);
63                 let area_base = area.area_base_aligned().data();
64                 // 将area的末尾地址与PAGE_SIZE对齐，对齐时向下取整
65                 // let area_end = (area.base.data() + area.size) & !(MMA::PAGE_SHIFT);
66                 let area_end = area.area_end_aligned().data();
67 
68                 // 如果offset大于area_end，说明当前的物理内存区域已经分配完了，需要跳到下一个物理内存区域
69                 if offset >= area_end {
70                     continue;
71                 }
72 
73                 // 如果offset小于area_base ,说明当前的物理内存区域还没有分配过页帧，将offset设置为area_base
74                 if offset < area_base {
75                     offset = area_base;
76                 } else if offset < area_end {
77                     // 将offset对齐到PAGE_SIZE
78                     offset = (offset + (MMA::PAGE_SIZE - 1)) & !(MMA::PAGE_SIZE - 1);
79                 }
80                 // found
81                 if offset + MMA::PAGE_SIZE <= area_end {
82                     ret_offset_aligned = offset - area.area_base_aligned().data();
83                     found_start = true;
84                 }
85             }
86 
87             if found_start && area.area_base_aligned() < area.area_end_aligned() {
88                 result_area[res_cnt] = area;
89                 res_cnt += 1;
90             }
91         }
92 
93         let res_cnt = unsafe { Self::arch_remain_areas(result_area, res_cnt) };
94         if res_cnt == 0 {
95             return None;
96         } else {
97             return Some(ret_offset_aligned);
98         }
99     }
100 
101     #[inline(never)]
102     unsafe fn ensure_early_mapping(&self, start_paddr: PhysAddr, count: PageFrameCount) {
103         // 确保在内存管理未被初始化时，这地址已经被映射了
104         if mm_init_status() != MMInitStatus::Initialized {
105             // 映射涉及的页
106 
107             let iter = PhysPageFrameIter::new(
108                 PhysPageFrame::new(start_paddr),
109                 PhysPageFrame::new(start_paddr + count.bytes()),
110             );
111             let mapper =
112                 PageMapper::<MMA, _>::current(PageTableKind::Kernel, BumpAllocator::<MMA>::new(0));
113 
114             for p in iter {
115                 if mapper
116                     .translate(MMA::phys_2_virt(p.phys_address()).unwrap())
117                     .is_none()
118                 {
119                     let vaddr = MMA::phys_2_virt(p.phys_address()).unwrap();
120                     pseudo_map_phys(vaddr, p.phys_address(), PageFrameCount::new(1));
121                 }
122             }
123         }
124     }
125 }
126 
127 impl<MMA: MemoryManagementArch> FrameAllocator for BumpAllocator<MMA> {
128     /// @brief: 分配count个物理页帧
129     /// @param  mut self
130     /// @param  count 分配的页帧数量
131     /// @return 分配后的物理地址
132     unsafe fn allocate(&mut self, count: PageFrameCount) -> Option<(PhysAddr, PageFrameCount)> {
133         let mut offset = self.offset();
134 
135         let iter = mem_block_manager().to_iter_available();
136 
137         // 遍历所有的物理内存区域
138         for area in iter {
139             // 将area的base地址与PAGE_SIZE对齐，对齐时向上取整
140             // let area_base = (area.base.data() + MMA::PAGE_SHIFT) & !(MMA::PAGE_SHIFT);
141             let area_base = area.area_base_aligned().data();
142             // 将area的末尾地址与PAGE_SIZE对齐，对齐时向下取整
143             // let area_end = (area.base.data() + area.size) & !(MMA::PAGE_SHIFT);
144             let area_end = area.area_end_aligned().data();
145 
146             // 如果offset大于area_end，说明当前的物理内存区域已经分配完了，需要跳到下一个物理内存区域
147             if offset >= area_end {
148                 continue;
149             }
150 
151             // 如果offset小于area_base ,说明当前的物理内存区域还没有分配过页帧，将offset设置为area_base
152             if offset < area_base {
153                 offset = area_base;
154             } else if offset < area_end {
155                 // 将offset对齐到PAGE_SIZE
156                 offset = (offset + (MMA::PAGE_SIZE - 1)) & !(MMA::PAGE_SIZE - 1);
157             }
158             // 如果当前offset到area_end的距离大于等于count.data() * PAGE_SIZE，说明当前的物理内存区域足以分配count个页帧
159             if offset + count.data() * MMA::PAGE_SIZE <= area_end {
160                 let res_page_phys = offset;
161                 // 将offset增加至分配后的内存
162                 self.offset = offset + count.data() * MMA::PAGE_SIZE;
163 
164                 let r = (PhysAddr(res_page_phys), count);
165                 self.ensure_early_mapping(r.0, r.1);
166                 return Some(r);
167             }
168         }
169         return None;
170     }
171 
172     unsafe fn free(&mut self, _address: PhysAddr, _count: PageFrameCount) {
173         // TODO: 支持释放页帧
174         unimplemented!("BumpAllocator::free not implemented");
175     }
176     /// @brief: 获取内存区域页帧的使用情况
177     /// @param  self
178     /// @return 页帧的使用情况
179     unsafe fn usage(&self) -> PageFrameUsage {
180         let mut total = 0;
181         let mut used = 0;
182         let iter = mem_block_manager().to_iter_available();
183         for area in iter {
184             // 将area的base地址与PAGE_SIZE对齐，对其时向上取整
185             let area_base = (area.base.data() + MMA::PAGE_SHIFT) & !(MMA::PAGE_SHIFT);
186             // 将area的末尾地址与PAGE_SIZE对齐，对其时向下取整
187             let area_end = (area.base.data() + area.size) & !(MMA::PAGE_SHIFT);
188 
189             total += (area_end - area_base) >> MMA::PAGE_SHIFT;
190             // 如果offset大于area_end，说明当前物理区域被分配完，都需要加到used中
191             if self.offset >= area_end {
192                 used += (area_end - area_base) >> MMA::PAGE_SHIFT;
193             } else if self.offset < area_base {
194                 // 如果offset小于area_base，说明当前物理区域还没有分配过页帧，都不需要加到used中
195                 continue;
196             } else {
197                 used += (self.offset - area_base) >> MMA::PAGE_SHIFT;
198             }
199         }
200         let frame = PageFrameUsage::new(PageFrameCount::new(used), PageFrameCount::new(total));
201         return frame;
202     }
203 }
204