xref: /DragonOS/kernel/src/driver/firmware/efi/tables.rs (revision 2eab6dd743e94a86a685f1f3c01e599adf86610a)
1 use core::{ffi::CStr, mem::size_of};
2 
3 use hashbrown::Equivalent;
4 use log::{debug, error, info, warn};
5 use system_error::SystemError;
6 use uefi_raw::table::{
7     boot::{MemoryAttribute, MemoryType},
8     configuration::ConfigurationTable,
9 };
10 
11 use crate::{
12     arch::MMArch,
13     driver::firmware::efi::{
14         efi_manager,
15         guid::{DragonStubPayloadEFI, DRAGONSTUB_EFI_PAYLOAD_EFI_GUID},
16     },
17     mm::{
18         early_ioremap::EarlyIoRemap, memblock::mem_block_manager, MemoryManagementArch, PhysAddr,
19         VirtAddr,
20     },
21 };
22 
23 use super::{
24     guid::{
25         EFI_MEMORY_ATTRIBUTES_TABLE_GUID, EFI_MEMRESERVE_TABLE_GUID, EFI_SYSTEM_RESOURCE_TABLE_GUID,
26     },
27     EFIManager,
28 };
29 
30 /// 所有的要解析的表格的解析器
31 static TABLE_PARSERS: &[&TableMatcher] = &[
32     &TableMatcher::new(&MatchTableDragonStubPayloadEFI),
33     &TableMatcher::new(&MatchTableMemoryAttributes),
34     &TableMatcher::new(&MatchTableMemReserve),
35     &TableMatcher::new(&MatchTableEsrt),
36 ];
37 
38 impl EFIManager {
39     /// 显示EFI系统表头的信息
40     ///
41     /// ## 参数
42     ///
43     /// - header: system table表头
44     /// - firmware_vendor: firmware vendor字符串的物理地址
45     #[inline(never)]
report_systable_header( &self, header: &uefi_raw::table::Header, firmware_vendor: PhysAddr, )46     pub fn report_systable_header(
47         &self,
48         header: &uefi_raw::table::Header,
49         firmware_vendor: PhysAddr,
50     ) {
51         const TMPBUF_SIZE: usize = 100;
52 
53         let mut tmp_buf = [0u8; TMPBUF_SIZE];
54 
55         let fw_ptr =
56             EarlyIoRemap::map_not_aligned(firmware_vendor, TMPBUF_SIZE * size_of::<u16>(), true);
57         if let Ok(fw_ptr) = fw_ptr {
58             let slice =
59                 unsafe { core::slice::from_raw_parts(fw_ptr.data() as *const u16, TMPBUF_SIZE) };
60             for i in 0..(TMPBUF_SIZE - 1) {
61                 let val = slice[i];
62 
63                 if (val & 0xff) == 0 {
64                     break;
65                 }
66                 tmp_buf[i] = (val & 0xff) as u8;
67             }
68 
69             EarlyIoRemap::unmap(fw_ptr).map_err(|e|{
70                 error!("report systable header: failed to unmap systable header, fw_ptr: {fw_ptr:?}, err: {e:?}");
71                 e
72             }).ok();
73         } else {
74             warn!("report systable header: failed to map systable header, err: {fw_ptr:?}");
75         }
76 
77         let s = CStr::from_bytes_with_nul(&tmp_buf)
78             .unwrap_or_else(|_| CStr::from_bytes_with_nul(b"Unknown\0").unwrap());
79         info!("EFI version: {:?}, vendor: {:?}", header.revision, s);
80     }
81 
82     /// 解析EFI config table
parse_config_tables(&self, tables: &[ConfigurationTable]) -> Result<(), SystemError>83     pub fn parse_config_tables(&self, tables: &[ConfigurationTable]) -> Result<(), SystemError> {
84         for table in tables {
85             let mut flag = false;
86             'parser_loop: for parser in TABLE_PARSERS {
87                 if let Some(r) = parser.match_table(table) {
88                     // 有匹配结果
89                     if let Err(e) = r {
90                         warn!(
91                             "Failed to parse cfg table: '{}', err: {e:?}",
92                             parser.table.name()
93                         );
94                     }
95                     flag = true;
96                     break 'parser_loop;
97                 }
98             }
99 
100             if !flag {
101                 warn!("Cannot find parser for guid: {:?}", table.vendor_guid);
102             }
103         }
104 
105         // 如果存在mem reserve table
106         if let Some(mem_reserve) = efi_manager().inner_read().memreserve_table_paddr {
107             let mut prev_paddr = mem_reserve;
108             while !prev_paddr.is_null() {
109                 let vaddr = EarlyIoRemap::map_not_aligned(prev_paddr, MMArch::PAGE_SIZE, true)
110                     .map_err(|e| {
111                         error!(
112                             "Failed to map UEFI memreserve table, paddr: {prev_paddr:?}, err: {e:?}"
113                         );
114 
115                         SystemError::ENOMEM
116                     })?;
117 
118                 let p = unsafe {
119                     (vaddr.data() as *const LinuxEFIMemReserveTable)
120                         .as_ref()
121                         .unwrap()
122                 };
123 
124                 // reserve the entry itself
125                 let psize: usize = p.size.try_into().unwrap();
126                 mem_block_manager()
127                     .reserve_block(
128                         prev_paddr,
129                         size_of::<LinuxEFIMemReserveTable>()
130                             + size_of::<LinuxEFIMemReserveEntry>() * psize,
131                     )
132                     .map_err(|e| {
133                         error!("Failed to reserve block, paddr: {prev_paddr:?}, err: {e:?}");
134                         EarlyIoRemap::unmap(vaddr).unwrap();
135                         e
136                     })?;
137 
138                 let entries = unsafe {
139                     core::slice::from_raw_parts(
140                         (vaddr.data() as *const LinuxEFIMemReserveTable).add(1)
141                             as *const LinuxEFIMemReserveEntry,
142                         p.count as usize,
143                     )
144                 };
145                 // reserve the entries
146                 for entry in entries {
147                     mem_block_manager()
148                         .reserve_block(PhysAddr::new(entry.base), entry.size)
149                         .map_err(|e| {
150                             error!("Failed to reserve block, paddr: {prev_paddr:?}, err: {e:?}");
151                             EarlyIoRemap::unmap(vaddr).unwrap();
152                             e
153                         })?;
154                 }
155 
156                 prev_paddr = p.next_paddr;
157                 EarlyIoRemap::unmap(vaddr).unwrap();
158             }
159         }
160         return Ok(());
161     }
162 }
163 
164 /// A structure describing a region of memory.
165 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
166 #[repr(C)]
167 pub struct MemoryDescriptor {
168     /// Type of memory occupying this range.
169     pub ty: MemoryType,
170     /// Starting physical address.
171     pub phys_start: uefi_raw::PhysicalAddress,
172     /// Starting virtual address.
173     pub virt_start: uefi_raw::VirtualAddress,
174     /// Number of 4 KiB pages contained in this range.
175     pub page_count: u64,
176     /// The capability attributes of this memory range.
177     pub att: MemoryAttribute,
178 }
179 
180 #[allow(dead_code)]
181 impl MemoryDescriptor {
182     /// Memory descriptor version number.
183     pub const VERSION: u32 = 1;
184 
185     /// 当前内存描述符是否表示真实的内存
186     #[inline]
is_memory(&self) -> bool187     pub fn is_memory(&self) -> bool {
188         if self.att.contains(MemoryAttribute::WRITE_BACK)
189             || self.att.contains(MemoryAttribute::WRITE_THROUGH)
190             || self.att.contains(MemoryAttribute::WRITE_COMBINE)
191         {
192             return true;
193         }
194 
195         return false;
196     }
197 
198     /// 判断当前内存描述符所表示的区域是否能被作为系统内存使用
199     ///
200     /// ## 返回
201     ///
202     /// - `true` - 可以
203     /// - `false` - 不可以
is_usable_memory(&self) -> bool204     pub fn is_usable_memory(&self) -> bool {
205         match self.ty {
206             MemoryType::LOADER_CODE
207             | MemoryType::LOADER_DATA
208             | MemoryType::ACPI_RECLAIM
209             | MemoryType::BOOT_SERVICES_CODE
210             | MemoryType::BOOT_SERVICES_DATA
211             | MemoryType::CONVENTIONAL
212             | MemoryType::PERSISTENT_MEMORY => {
213                 // SPECIAL_PURPOSE的内存是“软保留”的,这意味着它最初被留出,
214                 // 但在启动后可以通过热插拔再次使用,或者分配给dax驱动程序。
215                 if self.att.contains(MemoryAttribute::SPECIAL_PURPOSE) {
216                     return false;
217                 }
218 
219                 // 根据规范,在调用ExitBootServices()之后,这些区域就不再被保留了。
220                 // 然而,只有当它们可以被映射为WRITE_BACK缓存时,我们才能将它们用作系统内存
221                 return self.att.contains(MemoryAttribute::WRITE_BACK);
222             }
223             _ => {
224                 return false;
225             }
226         }
227     }
228 }
229 
230 impl Default for MemoryDescriptor {
default() -> MemoryDescriptor231     fn default() -> MemoryDescriptor {
232         MemoryDescriptor {
233             ty: MemoryType::RESERVED,
234             phys_start: 0,
235             virt_start: 0,
236             page_count: 0,
237             att: MemoryAttribute::empty(),
238         }
239     }
240 }
241 
242 trait MatchTable: Send + Sync {
243     /// 配置表名(仅用于日志显示)
name(&self) -> &'static str244     fn name(&self) -> &'static str;
245 
246     /// 当前table的guid
guid(&self) -> &'static uefi_raw::Guid247     fn guid(&self) -> &'static uefi_raw::Guid;
248 
249     /// 匹配阶段时,匹配器要映射vendor_table的大小。
250     ///
251     /// 如果为0,则不映射
map_size(&self) -> usize252     fn map_size(&self) -> usize;
253 
254     /// 当表格被映射后,调用这个函数
255     ///
256     /// ## 锁
257     ///
258     /// 进入该函数前,不得持有efi_manager().inner的任何锁
post_process( &self, vendor_table_vaddr: Option<VirtAddr>, table_raw: &ConfigurationTable, ) -> Result<(), SystemError>259     fn post_process(
260         &self,
261         vendor_table_vaddr: Option<VirtAddr>,
262         table_raw: &ConfigurationTable,
263     ) -> Result<(), SystemError>;
264 }
265 
266 /// `DRAGONSTUB_EFI_PAYLOAD_EFI_GUID` 的匹配器
267 struct MatchTableDragonStubPayloadEFI;
268 
269 impl MatchTable for MatchTableDragonStubPayloadEFI {
name(&self) -> &'static str270     fn name(&self) -> &'static str {
271         "DragonStub Payload"
272     }
273 
guid(&self) -> &'static uefi_raw::Guid274     fn guid(&self) -> &'static uefi_raw::Guid {
275         &DRAGONSTUB_EFI_PAYLOAD_EFI_GUID
276     }
277 
map_size(&self) -> usize278     fn map_size(&self) -> usize {
279         core::mem::size_of::<DragonStubPayloadEFI>()
280     }
281 
post_process( &self, vendor_table_vaddr: Option<VirtAddr>, _table_raw: &ConfigurationTable, ) -> Result<(), SystemError>282     fn post_process(
283         &self,
284         vendor_table_vaddr: Option<VirtAddr>,
285         _table_raw: &ConfigurationTable,
286     ) -> Result<(), SystemError> {
287         let vendor_table_vaddr = vendor_table_vaddr.unwrap();
288         let data = unsafe { *(vendor_table_vaddr.data() as *const DragonStubPayloadEFI) };
289 
290         efi_manager().inner_write().dragonstub_load_info = Some(data);
291 
292         return Ok(());
293     }
294 }
295 
296 struct MatchTableMemoryAttributes;
297 
298 impl MatchTable for MatchTableMemoryAttributes {
name(&self) -> &'static str299     fn name(&self) -> &'static str {
300         "MemAttr"
301     }
302 
guid(&self) -> &'static uefi_raw::Guid303     fn guid(&self) -> &'static uefi_raw::Guid {
304         &EFI_MEMORY_ATTRIBUTES_TABLE_GUID
305     }
306 
map_size(&self) -> usize307     fn map_size(&self) -> usize {
308         // 不映射
309         0
310     }
311 
post_process( &self, _vendor_table_vaddr: Option<VirtAddr>, table_raw: &ConfigurationTable, ) -> Result<(), SystemError>312     fn post_process(
313         &self,
314         _vendor_table_vaddr: Option<VirtAddr>,
315         table_raw: &ConfigurationTable,
316     ) -> Result<(), SystemError> {
317         efi_manager()
318             .inner
319             .write_irqsave()
320             .memory_attribute_table_paddr = Some(PhysAddr::new(table_raw.vendor_table as usize));
321         return Ok(());
322     }
323 }
324 
325 struct MatchTableMemReserve;
326 
327 impl MatchTable for MatchTableMemReserve {
name(&self) -> &'static str328     fn name(&self) -> &'static str {
329         "MemReserve"
330     }
331 
guid(&self) -> &'static uefi_raw::Guid332     fn guid(&self) -> &'static uefi_raw::Guid {
333         &EFI_MEMRESERVE_TABLE_GUID
334     }
335 
map_size(&self) -> usize336     fn map_size(&self) -> usize {
337         // 不映射
338         0
339     }
340 
post_process( &self, _vendor_table_vaddr: Option<VirtAddr>, table_raw: &ConfigurationTable, ) -> Result<(), SystemError>341     fn post_process(
342         &self,
343         _vendor_table_vaddr: Option<VirtAddr>,
344         table_raw: &ConfigurationTable,
345     ) -> Result<(), SystemError> {
346         efi_manager().inner.write_irqsave().memreserve_table_paddr =
347             Some(PhysAddr::new(table_raw.vendor_table as usize));
348         debug!(
349             "memreserve_table_paddr: {:#x}",
350             table_raw.vendor_table as usize
351         );
352         return Ok(());
353     }
354 }
355 
356 struct MatchTableEsrt;
357 
358 impl MatchTable for MatchTableEsrt {
name(&self) -> &'static str359     fn name(&self) -> &'static str {
360         "ESRT"
361     }
362 
guid(&self) -> &'static uefi_raw::Guid363     fn guid(&self) -> &'static uefi_raw::Guid {
364         &EFI_SYSTEM_RESOURCE_TABLE_GUID
365     }
366 
map_size(&self) -> usize367     fn map_size(&self) -> usize {
368         0
369     }
370 
post_process( &self, _vendor_table_vaddr: Option<VirtAddr>, table_raw: &ConfigurationTable, ) -> Result<(), SystemError>371     fn post_process(
372         &self,
373         _vendor_table_vaddr: Option<VirtAddr>,
374         table_raw: &ConfigurationTable,
375     ) -> Result<(), SystemError> {
376         efi_manager().inner.write_irqsave().esrt_table_paddr =
377             Some(PhysAddr::new(table_raw.vendor_table as usize));
378         debug!("esrt_table_paddr: {:#x}", table_raw.vendor_table as usize);
379         return Ok(());
380     }
381 }
382 
383 /// 用于匹配配置表的匹配器
384 struct TableMatcher {
385     table: &'static dyn MatchTable,
386 }
387 
388 impl TableMatcher {
new(table: &'static dyn MatchTable) -> Self389     const fn new(table: &'static dyn MatchTable) -> Self {
390         Self { table }
391     }
392 
393     /// 判断配置表与当前匹配器是否匹配
394     #[inline(never)]
match_table(&self, table: &ConfigurationTable) -> Option<Result<(), SystemError>>395     fn match_table(&self, table: &ConfigurationTable) -> Option<Result<(), SystemError>> {
396         if !table.vendor_guid.equivalent(self.table.guid()) {
397             return None;
398         }
399 
400         let table_map_size = self.table.map_size();
401 
402         let vendor_table_vaddr: Option<VirtAddr> = if table_map_size > 0 {
403             let table_paddr: PhysAddr = PhysAddr::new(table.vendor_table as usize);
404             let vaddr = EarlyIoRemap::map_not_aligned(table_paddr, table_map_size, true);
405 
406             if let Err(e) = vaddr {
407                 return Some(Err(e));
408             }
409 
410             Some(vaddr.unwrap())
411         } else {
412             None
413         };
414 
415         let r = self.table.post_process(vendor_table_vaddr, table);
416 
417         if let Some(vaddr) = vendor_table_vaddr {
418             EarlyIoRemap::unmap(vaddr).unwrap();
419         }
420         return Some(r);
421     }
422 }
423 
424 #[repr(C)]
425 #[derive(Debug)]
426 struct LinuxEFIMemReserveTable {
427     /// allocated size of the array
428     size: i32,
429     /// number of entries used
430     count: i32,
431     /// pa of next struct instance
432     next_paddr: PhysAddr,
433     entry: [LinuxEFIMemReserveEntry; 0],
434 }
435 
436 #[repr(C)]
437 #[derive(Debug)]
438 struct LinuxEFIMemReserveEntry {
439     base: usize,
440     size: usize,
441 }
442