Rename aster-frame to ostd

ostd/libs/linux-bzimage/setup/src/loader.rs

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MPL-2.0
+
+use xmas_elf::program::{ProgramHeader, SegmentData};
+
+/// Load the kernel ELF payload to memory.
+pub fn load_elf(file: &[u8]) {
+    let elf = xmas_elf::ElfFile::new(file).unwrap();
+
+    for ph in elf.program_iter() {
+        let ProgramHeader::Ph64(program) = ph else {
+            panic!(
+                "[setup] Unexpected program header type! Asterinas should be 64-bit ELF binary."
+            );
+        };
+        if program.get_type().unwrap() == xmas_elf::program::Type::Load {
+            load_segment(&elf, program);
+        }
+    }
+}
+
+fn load_segment(file: &xmas_elf::ElfFile, program: &xmas_elf::program::ProgramHeader64) {
+    let SegmentData::Undefined(header_data) = program.get_data(file).unwrap() else {
+        panic!("[setup] Unexpected segment data type!");
+    };
+    // SAFETY: the physical address from the ELF file is valid
+    let dst_slice = unsafe {
+        core::slice::from_raw_parts_mut(program.physical_addr as *mut u8, program.mem_size as usize)
+    };
+    /* crate::println!(
+        "[setup loader debug] loading ELF segment at {:#x}, size = {:#x}",
+        program.physical_addr,
+        program.mem_size,
+    ); */
+    #[cfg(feature = "debug_print")]
+    unsafe {
+        use crate::console::{print_hex, print_str};
+        print_str("[setup loader debug] loading ELF segment at ");
+        print_hex(program.physical_addr as u64);
+        print_str(", size = ");
+        print_hex(program.mem_size as u64);
+        print_str("\n");
+    }
+    // SAFETY: the ELF file is valid
+    // dst_slice[..program.file_size as usize].copy_from_slice(header_data);
+    unsafe {
+        memcpy(
+            dst_slice.as_mut_ptr(),
+            header_data.as_ptr(),
+            program.file_size as usize,
+        );
+    }
+    let zero_slice = &mut dst_slice[program.file_size as usize..];
+    zero_slice.fill(0);
+}
+
+/// TODO: remove this and use copy_from_slice instead
+///
+/// We use a custom memcpy because the standard library's compiler's builtin memcpy
+/// fails for some unknown reason. Sometimes that will result in "Unknown OPCode"
+/// machine error.
+unsafe fn memcpy(dst: *mut u8, src: *const u8, size: usize) {
+    let mut i = 0;
+    while i < size {
+        *dst.add(i) = *src.add(i);
+        i += 1;
+    }
+}