|
|
@@ -0,0 +1,600 @@
|
|
|
+use super::{LoadInfo, ELF_MAGIC};
|
|
|
+
|
|
|
+use crate::io::UninitBuffer;
|
|
|
+use crate::kernel::task::loader::aux_vec::{AuxKey, AuxVec};
|
|
|
+use crate::path::Path;
|
|
|
+use crate::{
|
|
|
+ io::ByteBuffer,
|
|
|
+ kernel::{
|
|
|
+ constants::ENOEXEC,
|
|
|
+ mem::{FileMapping, MMList, Mapping, Permission},
|
|
|
+ vfs::{dentry::Dentry, FsContext},
|
|
|
+ },
|
|
|
+ prelude::*,
|
|
|
+};
|
|
|
+use align_ext::AlignExt;
|
|
|
+use alloc::vec::Vec;
|
|
|
+use alloc::{ffi::CString, sync::Arc};
|
|
|
+use eonix_mm::{
|
|
|
+ address::{Addr, AddrOps as _, VAddr},
|
|
|
+ paging::PAGE_SIZE,
|
|
|
+};
|
|
|
+
|
|
|
+use xmas_elf::{
|
|
|
+ header::{self, Class, HeaderPt1, Machine_},
|
|
|
+ program::{self, ProgramHeader32, ProgramHeader64},
|
|
|
+};
|
|
|
+
|
|
|
+const INIT_STACK_SIZE: usize = 0x80_0000;
|
|
|
+
|
|
|
+#[derive(Debug, Clone, Copy)]
|
|
|
+#[repr(C)]
|
|
|
+struct HeaderPt2<P> {
|
|
|
+ type_: header::Type_,
|
|
|
+ machine: Machine_,
|
|
|
+ version: u32,
|
|
|
+ entry_point: P,
|
|
|
+ ph_offset: P,
|
|
|
+ sh_offset: P,
|
|
|
+ flags: u32,
|
|
|
+ header_size: u16,
|
|
|
+ ph_entry_size: u16,
|
|
|
+ ph_count: u16,
|
|
|
+ sh_entry_size: u16,
|
|
|
+ sh_count: u16,
|
|
|
+ sh_str_index: u16,
|
|
|
+}
|
|
|
+
|
|
|
+#[derive(Debug, Clone, Copy)]
|
|
|
+#[repr(C)]
|
|
|
+struct ElfHeader<P> {
|
|
|
+ pt1: HeaderPt1,
|
|
|
+ pt2: HeaderPt2<P>,
|
|
|
+}
|
|
|
+
|
|
|
+trait ProgramHeader {
|
|
|
+ fn offset(&self) -> usize;
|
|
|
+ fn file_size(&self) -> usize;
|
|
|
+ fn virtual_addr(&self) -> usize;
|
|
|
+ fn mem_size(&self) -> usize;
|
|
|
+ fn flags(&self) -> program::Flags;
|
|
|
+ fn type_(&self) -> KResult<program::Type>;
|
|
|
+}
|
|
|
+
|
|
|
+macro_rules! impl_program_header {
|
|
|
+ ($ProgramHeaderN:ident) => {
|
|
|
+ impl ProgramHeader for $ProgramHeaderN {
|
|
|
+ fn offset(&self) -> usize {
|
|
|
+ self.offset as usize
|
|
|
+ }
|
|
|
+
|
|
|
+ fn file_size(&self) -> usize {
|
|
|
+ self.file_size as usize
|
|
|
+ }
|
|
|
+
|
|
|
+ fn virtual_addr(&self) -> usize {
|
|
|
+ self.virtual_addr as usize
|
|
|
+ }
|
|
|
+
|
|
|
+ fn mem_size(&self) -> usize {
|
|
|
+ self.mem_size as usize
|
|
|
+ }
|
|
|
+
|
|
|
+ fn flags(&self) -> program::Flags {
|
|
|
+ self.flags
|
|
|
+ }
|
|
|
+
|
|
|
+ fn type_(&self) -> KResult<program::Type> {
|
|
|
+ self.get_type().map_err(|_| ENOEXEC)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+}
|
|
|
+
|
|
|
+impl_program_header!(ProgramHeader32);
|
|
|
+impl_program_header!(ProgramHeader64);
|
|
|
+
|
|
|
+struct LdsoLoadInfo {
|
|
|
+ base: VAddr,
|
|
|
+ entry_ip: VAddr,
|
|
|
+}
|
|
|
+
|
|
|
+trait ElfAddr {
|
|
|
+ type Integer;
|
|
|
+
|
|
|
+ fn from_usize(val: usize) -> Self;
|
|
|
+ fn into_usize(&self) -> usize;
|
|
|
+}
|
|
|
+
|
|
|
+macro_rules! impl_elf_addr {
|
|
|
+ ($Type:ident) => {
|
|
|
+ impl ElfAddr for $Type {
|
|
|
+ type Integer = $Type;
|
|
|
+
|
|
|
+ fn from_usize(val: usize) -> Self {
|
|
|
+ val as Self::Integer
|
|
|
+ }
|
|
|
+
|
|
|
+ fn into_usize(&self) -> usize {
|
|
|
+ *self as usize
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+}
|
|
|
+
|
|
|
+impl_elf_addr!(u32);
|
|
|
+impl_elf_addr!(u64);
|
|
|
+
|
|
|
+trait ElfArch {
|
|
|
+ type Ea: ElfAddr + Clone + Copy;
|
|
|
+ type Ph: ProgramHeader + Clone + Copy + Default;
|
|
|
+
|
|
|
+ const DYN_BASE_ADDR: usize;
|
|
|
+ const LDSO_BASE_ADDR: usize;
|
|
|
+ const STACK_BASE_ADDR: usize;
|
|
|
+}
|
|
|
+
|
|
|
+struct ElfArch32;
|
|
|
+
|
|
|
+struct ElfArch64;
|
|
|
+
|
|
|
+struct Elf<E: ElfArch> {
|
|
|
+ file: Arc<Dentry>,
|
|
|
+ elf_header: ElfHeader<E::Ea>,
|
|
|
+ program_headers: Vec<E::Ph>,
|
|
|
+}
|
|
|
+
|
|
|
+impl ElfArch for ElfArch32 {
|
|
|
+ type Ea = u32;
|
|
|
+ type Ph = ProgramHeader32;
|
|
|
+
|
|
|
+ const DYN_BASE_ADDR: usize = 0x4000_0000;
|
|
|
+ const LDSO_BASE_ADDR: usize = 0xf000_0000;
|
|
|
+ const STACK_BASE_ADDR: usize = 0xffff_0000;
|
|
|
+}
|
|
|
+
|
|
|
+impl ElfArch for ElfArch64 {
|
|
|
+ type Ea = u64;
|
|
|
+ type Ph = ProgramHeader64;
|
|
|
+
|
|
|
+ const DYN_BASE_ADDR: usize = 0xaaaa_0000_0000;
|
|
|
+ const LDSO_BASE_ADDR: usize = 0xf000_0000_0000;
|
|
|
+ const STACK_BASE_ADDR: usize = 0xffff_ffff_0000;
|
|
|
+}
|
|
|
+
|
|
|
+impl<E: ElfArch> Elf<E> {
|
|
|
+ fn is_shared_object(&self) -> bool {
|
|
|
+ self.elf_header.pt2.type_.as_type() == header::Type::SharedObject
|
|
|
+ }
|
|
|
+
|
|
|
+ fn entry_point(&self) -> usize {
|
|
|
+ self.elf_header.pt2.entry_point.into_usize()
|
|
|
+ }
|
|
|
+
|
|
|
+ fn ph_count(&self) -> usize {
|
|
|
+ self.elf_header.pt2.ph_count as usize
|
|
|
+ }
|
|
|
+
|
|
|
+ fn ph_offset(&self) -> usize {
|
|
|
+ self.elf_header.pt2.ph_offset.into_usize()
|
|
|
+ }
|
|
|
+
|
|
|
+ fn ph_entry_size(&self) -> usize {
|
|
|
+ self.elf_header.pt2.ph_entry_size as usize
|
|
|
+ }
|
|
|
+
|
|
|
+ fn ph_addr(&self) -> KResult<usize> {
|
|
|
+ let ph_offset = self.ph_offset();
|
|
|
+ for program_header in &self.program_headers {
|
|
|
+ if program_header.offset() <= ph_offset
|
|
|
+ && ph_offset < program_header.offset() + program_header.file_size()
|
|
|
+ {
|
|
|
+ return Ok(ph_offset - program_header.offset() + program_header.virtual_addr());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Err(ENOEXEC)
|
|
|
+ }
|
|
|
+
|
|
|
+ fn parse(elf_file: Arc<Dentry>) -> KResult<Self> {
|
|
|
+ let mut elf_header = UninitBuffer::<ElfHeader<E::Ea>>::new();
|
|
|
+ elf_file.read(&mut elf_header, 0)?;
|
|
|
+
|
|
|
+ let elf_header = elf_header.assume_init().map_err(|_| ENOEXEC)?;
|
|
|
+
|
|
|
+ let ph_offset = elf_header.pt2.ph_offset;
|
|
|
+ let ph_count = elf_header.pt2.ph_count;
|
|
|
+
|
|
|
+ let mut program_headers = vec![E::Ph::default(); ph_count as usize];
|
|
|
+ elf_file.read(
|
|
|
+ &mut ByteBuffer::from(program_headers.as_mut_slice()),
|
|
|
+ ph_offset.into_usize(),
|
|
|
+ )?;
|
|
|
+
|
|
|
+ Ok(Self {
|
|
|
+ file: elf_file,
|
|
|
+ elf_header,
|
|
|
+ program_headers,
|
|
|
+ })
|
|
|
+ }
|
|
|
+
|
|
|
+ fn load(&self, args: Vec<CString>, envs: Vec<CString>) -> KResult<LoadInfo> {
|
|
|
+ let mm_list = MMList::new();
|
|
|
+
|
|
|
+ // Load Segments
|
|
|
+ let (elf_base, data_segment_end) = self.load_segments(&mm_list)?;
|
|
|
+
|
|
|
+ // Load ldso(if have)
|
|
|
+ let ldso_load_info = self.load_ldso(&mm_list)?;
|
|
|
+
|
|
|
+ // Heap
|
|
|
+ mm_list.register_break(data_segment_end + 0x10000);
|
|
|
+
|
|
|
+ let aux_vec = self.init_aux_vec(
|
|
|
+ elf_base,
|
|
|
+ ldso_load_info
|
|
|
+ .as_ref()
|
|
|
+ .map(|ldso_load_info| ldso_load_info.base),
|
|
|
+ )?;
|
|
|
+
|
|
|
+ // Map stack
|
|
|
+ let sp = self.create_and_init_stack(&mm_list, args, envs, aux_vec)?;
|
|
|
+
|
|
|
+ let entry_ip = if let Some(ldso_load_info) = ldso_load_info {
|
|
|
+ // Normal shared object(DYN)
|
|
|
+ ldso_load_info.entry_ip.into()
|
|
|
+ } else if self.is_shared_object() {
|
|
|
+ // ldso itself
|
|
|
+ elf_base + self.entry_point()
|
|
|
+ } else {
|
|
|
+ // statically linked executable
|
|
|
+ self.entry_point().into()
|
|
|
+ };
|
|
|
+
|
|
|
+ Ok(LoadInfo {
|
|
|
+ entry_ip,
|
|
|
+ sp,
|
|
|
+ mm_list,
|
|
|
+ })
|
|
|
+ }
|
|
|
+
|
|
|
+ fn create_and_init_stack(
|
|
|
+ &self,
|
|
|
+ mm_list: &MMList,
|
|
|
+ args: Vec<CString>,
|
|
|
+ envs: Vec<CString>,
|
|
|
+ aux_vec: AuxVec<E::Ea>,
|
|
|
+ ) -> KResult<VAddr> {
|
|
|
+ mm_list.mmap_fixed(
|
|
|
+ VAddr::from(E::STACK_BASE_ADDR - INIT_STACK_SIZE),
|
|
|
+ INIT_STACK_SIZE,
|
|
|
+ Mapping::Anonymous,
|
|
|
+ Permission {
|
|
|
+ read: true,
|
|
|
+ write: true,
|
|
|
+ execute: false,
|
|
|
+ },
|
|
|
+ )?;
|
|
|
+
|
|
|
+ StackInitializer::new(&mm_list, E::STACK_BASE_ADDR, args, envs, aux_vec).init()
|
|
|
+ }
|
|
|
+
|
|
|
+ fn init_aux_vec(&self, elf_base: VAddr, ldso_base: Option<VAddr>) -> KResult<AuxVec<E::Ea>> {
|
|
|
+ let mut aux_vec: AuxVec<E::Ea> = AuxVec::new();
|
|
|
+ let ph_addr = if self.is_shared_object() {
|
|
|
+ elf_base.addr() + self.ph_addr()?
|
|
|
+ } else {
|
|
|
+ self.ph_addr()?
|
|
|
+ };
|
|
|
+
|
|
|
+ aux_vec.set(AuxKey::AT_PAGESZ, E::Ea::from_usize(PAGE_SIZE))?;
|
|
|
+ aux_vec.set(AuxKey::AT_PHDR, E::Ea::from_usize(ph_addr))?;
|
|
|
+ aux_vec.set(AuxKey::AT_PHNUM, E::Ea::from_usize(self.ph_count()))?;
|
|
|
+ aux_vec.set(AuxKey::AT_PHENT, E::Ea::from_usize(self.ph_entry_size()))?;
|
|
|
+ let elf_entry = if self.is_shared_object() {
|
|
|
+ elf_base.addr() + self.entry_point()
|
|
|
+ } else {
|
|
|
+ self.entry_point()
|
|
|
+ };
|
|
|
+ aux_vec.set(AuxKey::AT_ENTRY, E::Ea::from_usize(elf_entry))?;
|
|
|
+
|
|
|
+ if let Some(ldso_base) = ldso_base {
|
|
|
+ aux_vec.set(AuxKey::AT_BASE, E::Ea::from_usize(ldso_base.addr()))?;
|
|
|
+ }
|
|
|
+ Ok(aux_vec)
|
|
|
+ }
|
|
|
+
|
|
|
+ fn load_segments(&self, mm_list: &MMList) -> KResult<(VAddr, VAddr)> {
|
|
|
+ let base: VAddr = if self.is_shared_object() { E::DYN_BASE_ADDR } else { 0 }.into();
|
|
|
+
|
|
|
+ let mut segments_end = VAddr::NULL;
|
|
|
+
|
|
|
+ for program_header in &self.program_headers {
|
|
|
+ let type_ = program_header.type_().map_err(|_| ENOEXEC)?;
|
|
|
+
|
|
|
+ if type_ == program::Type::Load {
|
|
|
+ let segment_end = self.load_segment(program_header, mm_list, base)?;
|
|
|
+
|
|
|
+ if segment_end > segments_end {
|
|
|
+ segments_end = segment_end;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ Ok((base, segments_end))
|
|
|
+ }
|
|
|
+
|
|
|
+ fn load_segment(
|
|
|
+ &self,
|
|
|
+ program_header: &E::Ph,
|
|
|
+ mm_list: &MMList,
|
|
|
+ base_addr: VAddr,
|
|
|
+ ) -> KResult<VAddr> {
|
|
|
+ let virtual_addr = base_addr + program_header.virtual_addr();
|
|
|
+ let vmem_vaddr_end = virtual_addr + program_header.mem_size();
|
|
|
+ let load_vaddr_end = virtual_addr + program_header.file_size();
|
|
|
+
|
|
|
+ let vmap_start = virtual_addr.floor();
|
|
|
+ let vmem_len = vmem_vaddr_end.ceil() - vmap_start;
|
|
|
+ let file_len = load_vaddr_end.ceil() - vmap_start;
|
|
|
+ let file_offset = (program_header.offset()).align_down(PAGE_SIZE);
|
|
|
+
|
|
|
+ let permission = Permission {
|
|
|
+ read: program_header.flags().is_read(),
|
|
|
+ write: program_header.flags().is_write(),
|
|
|
+ execute: program_header.flags().is_execute(),
|
|
|
+ };
|
|
|
+
|
|
|
+ if file_len != 0 {
|
|
|
+ let real_file_length = load_vaddr_end - vmap_start;
|
|
|
+
|
|
|
+ mm_list.mmap_fixed(
|
|
|
+ vmap_start,
|
|
|
+ file_len,
|
|
|
+ Mapping::File(FileMapping::new(
|
|
|
+ self.file.clone(),
|
|
|
+ file_offset,
|
|
|
+ real_file_length,
|
|
|
+ )),
|
|
|
+ permission,
|
|
|
+ )?;
|
|
|
+ }
|
|
|
+
|
|
|
+ if vmem_len > file_len {
|
|
|
+ mm_list.mmap_fixed(
|
|
|
+ vmap_start + file_len,
|
|
|
+ vmem_len - file_len,
|
|
|
+ Mapping::Anonymous,
|
|
|
+ permission,
|
|
|
+ )?;
|
|
|
+ }
|
|
|
+
|
|
|
+ Ok(vmap_start + vmem_len)
|
|
|
+ }
|
|
|
+
|
|
|
+ fn load_ldso(&self, mm_list: &MMList) -> KResult<Option<LdsoLoadInfo>> {
|
|
|
+ let ldso_path = self.ldso_path()?;
|
|
|
+
|
|
|
+ if let Some(ldso_path) = ldso_path {
|
|
|
+ let fs_context = FsContext::global();
|
|
|
+ let ldso_file =
|
|
|
+ Dentry::open(fs_context, Path::new(ldso_path.as_bytes()).unwrap(), true).unwrap();
|
|
|
+ let ldso_elf = Elf::<E>::parse(ldso_file).unwrap();
|
|
|
+
|
|
|
+ let base = VAddr::from(E::LDSO_BASE_ADDR);
|
|
|
+
|
|
|
+ for program_header in &ldso_elf.program_headers {
|
|
|
+ let type_ = program_header.type_().map_err(|_| ENOEXEC)?;
|
|
|
+
|
|
|
+ if type_ == program::Type::Load {
|
|
|
+ ldso_elf.load_segment(program_header, mm_list, base)?;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return Ok(Some(LdsoLoadInfo {
|
|
|
+ base,
|
|
|
+ entry_ip: base + ldso_elf.entry_point() as usize,
|
|
|
+ }));
|
|
|
+ }
|
|
|
+
|
|
|
+ Ok(None)
|
|
|
+ }
|
|
|
+
|
|
|
+ fn ldso_path(&self) -> KResult<Option<String>> {
|
|
|
+ for program_header in &self.program_headers {
|
|
|
+ let type_ = program_header.type_().map_err(|_| ENOEXEC)?;
|
|
|
+
|
|
|
+ if type_ == program::Type::Interp {
|
|
|
+ let file_size = program_header.file_size();
|
|
|
+ let file_offset = program_header.offset();
|
|
|
+
|
|
|
+ let mut ldso_vec = vec![0u8; file_size - 1]; // -1 due to '\0'
|
|
|
+ self.file
|
|
|
+ .read(&mut ByteBuffer::from(ldso_vec.as_mut_slice()), file_offset)?;
|
|
|
+ let ldso_path = String::from_utf8(ldso_vec).map_err(|_| ENOEXEC)?;
|
|
|
+ return Ok(Some(ldso_path));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Ok(None)
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+pub enum ELF {
|
|
|
+ Elf32(Elf<ElfArch32>),
|
|
|
+ Elf64(Elf<ElfArch64>),
|
|
|
+}
|
|
|
+
|
|
|
+impl ELF {
|
|
|
+ pub fn parse(elf_file: Arc<Dentry>) -> KResult<Self> {
|
|
|
+ let mut header_pt1 = UninitBuffer::<HeaderPt1>::new();
|
|
|
+ elf_file.read(&mut header_pt1, 0)?;
|
|
|
+
|
|
|
+ let header_pt1 = header_pt1.assume_init().map_err(|_| ENOEXEC)?;
|
|
|
+ assert_eq!(header_pt1.magic, ELF_MAGIC);
|
|
|
+
|
|
|
+ match header_pt1.class() {
|
|
|
+ Class::ThirtyTwo => Ok(ELF::Elf32(Elf::parse(elf_file)?)),
|
|
|
+ Class::SixtyFour => Ok(ELF::Elf64(Elf::parse(elf_file)?)),
|
|
|
+ _ => Err(ENOEXEC),
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ pub fn load(&self, args: Vec<CString>, envs: Vec<CString>) -> KResult<LoadInfo> {
|
|
|
+ match &self {
|
|
|
+ ELF::Elf32(elf32) => elf32.load(args, envs),
|
|
|
+ ELF::Elf64(elf64) => elf64.load(args, envs),
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+struct StackInitializer<'a, T> {
|
|
|
+ mm_list: &'a MMList,
|
|
|
+ sp: usize,
|
|
|
+ args: Vec<CString>,
|
|
|
+ envs: Vec<CString>,
|
|
|
+ aux_vec: AuxVec<T>,
|
|
|
+}
|
|
|
+
|
|
|
+impl<'a, T: ElfAddr + Clone + Copy> StackInitializer<'a, T> {
|
|
|
+ fn new(
|
|
|
+ mm_list: &'a MMList,
|
|
|
+ sp: usize,
|
|
|
+ args: Vec<CString>,
|
|
|
+ envs: Vec<CString>,
|
|
|
+ aux_vec: AuxVec<T>,
|
|
|
+ ) -> Self {
|
|
|
+ Self {
|
|
|
+ mm_list,
|
|
|
+ sp,
|
|
|
+ args,
|
|
|
+ envs,
|
|
|
+ aux_vec,
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // return sp after stack init
|
|
|
+ fn init(mut self) -> KResult<VAddr> {
|
|
|
+ let env_pointers = self.push_envs()?;
|
|
|
+ let arg_pointers = self.push_args()?;
|
|
|
+
|
|
|
+ self.stack_alignment();
|
|
|
+ self.push_aux_vec()?;
|
|
|
+ self.push_pointers(env_pointers)?;
|
|
|
+ self.push_pointers(arg_pointers)?;
|
|
|
+ self.push_argc(T::from_usize(self.args.len()))?;
|
|
|
+
|
|
|
+ assert_eq!(self.sp.align_down(16), self.sp);
|
|
|
+ Ok(VAddr::from(self.sp))
|
|
|
+ }
|
|
|
+
|
|
|
+ fn push_envs(&mut self) -> KResult<Vec<T>> {
|
|
|
+ let mut addrs = Vec::with_capacity(self.envs.len());
|
|
|
+ for string in self.envs.iter().rev() {
|
|
|
+ let len = string.as_bytes_with_nul().len();
|
|
|
+ self.sp -= len;
|
|
|
+ self.mm_list
|
|
|
+ .access_mut(VAddr::from(self.sp), len, |offset, data| {
|
|
|
+ data.copy_from_slice(&string.as_bytes_with_nul()[offset..offset + data.len()])
|
|
|
+ })?;
|
|
|
+ addrs.push(T::from_usize(self.sp));
|
|
|
+ }
|
|
|
+ addrs.reverse();
|
|
|
+ Ok(addrs)
|
|
|
+ }
|
|
|
+
|
|
|
+ fn push_args(&mut self) -> KResult<Vec<T>> {
|
|
|
+ let mut addrs = Vec::with_capacity(self.args.len());
|
|
|
+ for string in self.args.iter().rev() {
|
|
|
+ let len = string.as_bytes_with_nul().len();
|
|
|
+ self.sp -= len;
|
|
|
+ self.mm_list
|
|
|
+ .access_mut(VAddr::from(self.sp), len, |offset, data| {
|
|
|
+ data.copy_from_slice(&string.as_bytes_with_nul()[offset..offset + data.len()])
|
|
|
+ })?;
|
|
|
+ addrs.push(T::from_usize(self.sp));
|
|
|
+ }
|
|
|
+ addrs.reverse();
|
|
|
+ Ok(addrs)
|
|
|
+ }
|
|
|
+
|
|
|
+ fn stack_alignment(&mut self) {
|
|
|
+ let aux_vec_size = (self.aux_vec.table().len() + 1) * (size_of::<T>() * 2);
|
|
|
+ let envp_pointers_size = (self.envs.len() + 1) * size_of::<T>();
|
|
|
+ let argv_pointers_size = (self.args.len() + 1) * size_of::<T>();
|
|
|
+ let argc_size = size_of::<T>();
|
|
|
+ let all_size = aux_vec_size + envp_pointers_size + argv_pointers_size + argc_size;
|
|
|
+
|
|
|
+ let align_sp = (self.sp - all_size).align_down(16);
|
|
|
+ self.sp = align_sp + all_size;
|
|
|
+ }
|
|
|
+
|
|
|
+ fn push_pointers(&mut self, mut pointers: Vec<T>) -> KResult<()> {
|
|
|
+ pointers.push(T::from_usize(0));
|
|
|
+ self.sp -= pointers.len() * size_of::<T>();
|
|
|
+
|
|
|
+ self.mm_list.access_mut(
|
|
|
+ VAddr::from(self.sp),
|
|
|
+ pointers.len() * size_of::<T>(),
|
|
|
+ |offset, data| {
|
|
|
+ data.copy_from_slice(unsafe {
|
|
|
+ core::slice::from_raw_parts(
|
|
|
+ pointers.as_ptr().byte_add(offset) as *const u8,
|
|
|
+ data.len(),
|
|
|
+ )
|
|
|
+ })
|
|
|
+ },
|
|
|
+ )?;
|
|
|
+
|
|
|
+ Ok(())
|
|
|
+ }
|
|
|
+
|
|
|
+ fn push_argc(&mut self, val: T) -> KResult<()> {
|
|
|
+ self.sp -= size_of::<T>();
|
|
|
+
|
|
|
+ self.mm_list
|
|
|
+ .access_mut(VAddr::from(self.sp), size_of::<u32>(), |_, data| {
|
|
|
+ data.copy_from_slice(unsafe {
|
|
|
+ core::slice::from_raw_parts(&val as *const _ as *const u8, data.len())
|
|
|
+ })
|
|
|
+ })?;
|
|
|
+
|
|
|
+ Ok(())
|
|
|
+ }
|
|
|
+
|
|
|
+ fn push_aux_vec(&mut self) -> KResult<()> {
|
|
|
+ let mut longs: Vec<T> = vec![];
|
|
|
+
|
|
|
+ // Write Auxiliary vectors
|
|
|
+ let aux_vec: Vec<_> = self
|
|
|
+ .aux_vec
|
|
|
+ .table()
|
|
|
+ .iter()
|
|
|
+ .map(|(aux_key, aux_value)| (*aux_key, *aux_value))
|
|
|
+ .collect();
|
|
|
+
|
|
|
+ for (aux_key, aux_value) in aux_vec.iter() {
|
|
|
+ longs.push(T::from_usize(*aux_key as usize));
|
|
|
+ longs.push(*aux_value);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Write NULL auxiliary
|
|
|
+ longs.push(T::from_usize(AuxKey::AT_NULL as usize));
|
|
|
+ longs.push(T::from_usize(0));
|
|
|
+
|
|
|
+ self.sp -= longs.len() * size_of::<T>();
|
|
|
+
|
|
|
+ self.mm_list.access_mut(
|
|
|
+ VAddr::from(self.sp),
|
|
|
+ longs.len() * size_of::<T>(),
|
|
|
+ |offset, data| {
|
|
|
+ data.copy_from_slice(unsafe {
|
|
|
+ core::slice::from_raw_parts(
|
|
|
+ longs.as_ptr().byte_add(offset) as *const u8,
|
|
|
+ data.len(),
|
|
|
+ )
|
|
|
+ })
|
|
|
+ },
|
|
|
+ )?;
|
|
|
+
|
|
|
+ Ok(())
|
|
|
+ }
|
|
|
+}
|
