Change the BootInformation and ElfSection* types into value types.

Author: ahmedcharles

src/elf_sections.rs

@@ -1,86 +1,90 @@
+use header::Tag;
 
 #[derive(Debug)]
-#[repr(packed)] // repr(C) would add unwanted padding before first_section
 pub struct ElfSectionsTag {
-    typ: u32,
-    size: u32,
+    inner: *const ElfSectionsTagInner,
+}
+
+pub fn elf_sections_tag(tag: &Tag) -> ElfSectionsTag {
+    assert_eq!(9, tag.typ);
+    let es = ElfSectionsTag {
+        inner: unsafe { (tag as *const _).offset(1) } as *const _,
+    };
+    assert!((es.get().entry_size * es.get().shndx) <= tag.size);
+    es
+}
+
+#[derive(Debug)]
+#[repr(C, packed)] // only repr(C) would add unwanted padding at the end
+struct ElfSectionsTagInner {
     number_of_sections: u32,
     entry_size: u32,
     shndx: u32, // string table
-    first_section: ElfSection,
 }
 
 impl ElfSectionsTag {
-    pub fn sections(&'static self) -> ElfSectionIter {
+    pub fn sections(&self) -> ElfSectionIter {
+        let string_section_offset = (self.get().shndx * self.get().entry_size) as isize;
+        let string_section_ptr = unsafe {
+            self.first_section().offset(string_section_offset) as *const _
+        };
         ElfSectionIter {
-            current_section: &self.first_section,
-            remaining_sections: self.number_of_sections - 1,
-            entry_size: self.entry_size,
+            current_section: self.first_section(),
+            remaining_sections: self.get().number_of_sections - 1,
+            entry_size: self.get().entry_size,
+            string_section: string_section_ptr,
         }
     }
 
-    pub fn string_table(&self) -> &'static StringTable {
-        unsafe {
-            let string_table_ptr =
-                (&self.first_section as *const ElfSection).offset(self.shndx as isize);
-            &*((*string_table_ptr).addr as *const StringTable)
-        }
+    fn first_section(&self) -> *const u8 {
+        (unsafe { self.inner.offset(1) }) as *const _
     }
-}
-
-pub struct StringTable(u8);
-
-impl StringTable {
-    pub fn section_name(&self, section: &ElfSection) -> &'static str {
-        use core::{str, slice};
 
-        let name_ptr = unsafe {
-            (&self.0 as *const u8).offset(section.name_index as isize)
-        };
-        let strlen = {
-            let mut len = 0;
-            while unsafe { *name_ptr.offset(len) } != 0 {
-                len += 1;
-            }
-            len as usize
-        };
-
-        str::from_utf8( unsafe {
-            slice::from_raw_parts(name_ptr, strlen)
-        }).unwrap()
+    fn get(&self) -> &ElfSectionsTagInner {
+        unsafe { &*self.inner }
     }
 }
 
 #[derive(Clone)]
 pub struct ElfSectionIter {
-    current_section: &'static ElfSection,
+    current_section: *const u8,
     remaining_sections: u32,
     entry_size: u32,
+    string_section: *const ElfSectionInner,
 }
 
 impl Iterator for ElfSectionIter {
-    type Item = &'static ElfSection;
-    fn next(&mut self) -> Option<&'static ElfSection> {
+    type Item = ElfSection;
+    fn next(&mut self) -> Option<ElfSection> {
         if self.remaining_sections == 0 {
-            None
-        } else {
-            let section = self.current_section;
-            let next_section_addr = (self.current_section as *const _ as u64) + self.entry_size as u64;
-            self.current_section = unsafe{ &*(next_section_addr as *const ElfSection) };
+            return None;
+        }
+
+        loop {
+            let section = ElfSection {
+                inner: self.current_section as *const ElfSectionInner,
+                string_section: self.string_section,
+            };
+
+            self.current_section = unsafe { self.current_section.offset(self.entry_size as isize) };
             self.remaining_sections -= 1;
-            if section.typ == ElfSectionType::Unused as u32 {
-                self.next()
-            } else {
-                Some(section)
+
+            if section.section_type() != ElfSectionType::Unused {
+                return Some(section);
             }
         }
     }
 }
 
+pub struct ElfSection {
+    inner: *const ElfSectionInner,
+    string_section: *const ElfSectionInner,
+}
+
 #[cfg(feature = "elf32")]
 #[derive(Debug)]
 #[repr(C)]
-pub struct ElfSection {
+struct ElfSectionInner {
     name_index: u32,
     typ: u32,
     flags: u32,
@@ -96,7 +100,7 @@ pub struct ElfSection {
 #[cfg(not(feature = "elf32"))]
 #[derive(Debug)]
 #[repr(C)]
-pub struct ElfSection {
+struct ElfSectionInner {
     name_index: u32,
     typ: u32,
     flags: u64,
@@ -111,7 +115,7 @@ pub struct ElfSection {
 
 impl ElfSection {
     pub fn section_type(&self) -> ElfSectionType {
-        match self.typ {
+        match self.get().typ {
             0 => ElfSectionType::Unused,
             1 => ElfSectionType::ProgramSection,
             2 => ElfSectionType::LinkerSymbolTable,
@@ -131,28 +135,53 @@ impl ElfSection {
     }
 
     pub fn section_type_raw(&self) -> u32 {
-        self.typ
+        self.get().typ
+    }
+
+    pub fn name(&self) -> &str {
+        use core::{str, slice};
+
+        let name_ptr = unsafe {
+            self.string_table().offset(self.get().name_index as isize)
+        };
+        let strlen = {
+            let mut len = 0;
+            while unsafe { *name_ptr.offset(len) } != 0 {
+                len += 1;
+            }
+            len as usize
+        };
+
+        str::from_utf8(unsafe { slice::from_raw_parts(name_ptr, strlen) }).unwrap()
     }
 
     pub fn start_address(&self) -> usize {
-        self.addr as usize
+        self.get().addr as usize
     }
 
     pub fn end_address(&self) -> usize {
-        (self.addr + self.size) as usize
+        (self.get().addr + self.get().size) as usize
     }
 
     pub fn size(&self) -> usize {
-        self.size as usize
+        self.get().size as usize
     }
 
     pub fn flags(&self) -> ElfSectionFlags {
-        ElfSectionFlags::from_bits_truncate(self.flags)
+        ElfSectionFlags::from_bits_truncate(self.get().flags)
     }
 
     pub fn is_allocated(&self) -> bool {
         self.flags().contains(ELF_SECTION_ALLOCATED)
     }
+
+    fn get(&self) -> &ElfSectionInner {
+        unsafe { &*self.inner }
+    }
+
+    unsafe fn string_table(&self) -> *const u8 {
+        (*self.string_section).addr as *const _
+    }
 }
 
 #[derive(PartialEq, Eq, Debug, Copy, Clone)]

src/lib.rs

@@ -4,7 +4,7 @@ use core::fmt;
 
 use header::{Tag, TagIter};
 pub use boot_loader_name::BootLoaderNameTag;
-pub use elf_sections::{ElfSectionsTag, ElfSection, ElfSectionIter, ElfSectionType, ElfSectionFlags, StringTable};
+pub use elf_sections::{ElfSectionsTag, ElfSection, ElfSectionIter, ElfSectionType, ElfSectionFlags};
 pub use elf_sections::{ELF_SECTION_WRITABLE, ELF_SECTION_ALLOCATED, ELF_SECTION_EXECUTABLE};
 pub use memory_map::{MemoryMapTag, MemoryArea, MemoryAreaIter};
 pub use module::{ModuleTag, ModuleIter};
@@ -20,38 +20,41 @@ mod memory_map;
 mod module;
 mod command_line;
 
-pub unsafe fn load(address: usize) -> &'static BootInformation {
+pub unsafe fn load(address: usize) -> BootInformation {
     if !cfg!(test) {
         assert_eq!(0, address & 0b111);
     }
-    let multiboot = &*(address as *const BootInformation);
+    let multiboot = &*(address as *const BootInformationInner);
     assert_eq!(0, multiboot.total_size & 0b111);
     assert!(multiboot.has_valid_end_tag());
-    multiboot
+    BootInformation { inner: multiboot }
 }
 
-#[repr(C)]
 pub struct BootInformation {
+    inner: *const BootInformationInner,
+}
+
+#[repr(C)]
+struct BootInformationInner {
     total_size: u32,
     _reserved: u32,
-    first_tag: Tag,
 }
 
 impl BootInformation {
     pub fn start_address(&self) -> usize {
-        self as *const _ as usize
+        self.inner as usize
     }
 
     pub fn end_address(&self) -> usize {
         self.start_address() + self.total_size()
     }
 
     pub fn total_size(&self) -> usize {
-        self.total_size as usize
+        self.get().total_size as usize
     }
 
-    pub fn elf_sections_tag(&self) -> Option<&'static ElfSectionsTag> {
-        self.get_tag(9).map(|tag| unsafe { &*(tag as *const Tag as *const ElfSectionsTag) })
+    pub fn elf_sections_tag(&self) -> Option<ElfSectionsTag> {
+        self.get_tag(9).map(|tag| elf_sections::elf_sections_tag(tag))
     }
 
     pub fn memory_map_tag(&self) -> Option<&'static MemoryMapTag> {
@@ -70,22 +73,28 @@ impl BootInformation {
         self.get_tag(1).map(|tag| unsafe { &*(tag as *const Tag as *const CommandLineTag) })
     }
 
-    fn has_valid_end_tag(&self) -> bool {
-        const END_TAG: Tag = Tag{typ:0, size:8};
-
-        let self_ptr = self as *const _;
-        let end_tag_addr = self_ptr as usize + (self.total_size - END_TAG.size) as usize;
-        let end_tag = unsafe{&*(end_tag_addr as *const Tag)};
-
-        end_tag.typ == END_TAG.typ && end_tag.size == END_TAG.size
+    fn get(&self) -> &BootInformationInner {
+        unsafe { &*self.inner }
     }
 
     fn get_tag(&self, typ: u32) -> Option<&'static Tag> {
         self.tags().find(|tag| tag.typ == typ)
     }
 
     fn tags(&self) -> TagIter {
-        TagIter { current: &self.first_tag as *const _ }
+        TagIter { current: unsafe { self.inner.offset(1) } as *const _ }
+    }
+}
+
+impl BootInformationInner {
+    fn has_valid_end_tag(&self) -> bool {
+        const END_TAG: Tag = Tag { typ: 0, size: 8 };
+
+        let self_ptr = self as *const _;
+        let end_tag_addr = self_ptr as usize + (self.total_size - END_TAG.size) as usize;
+        let end_tag = unsafe { &*(end_tag_addr as *const Tag) };
+
+        end_tag.typ == END_TAG.typ && end_tag.size == END_TAG.size
     }
 }
 
@@ -113,11 +122,10 @@ impl fmt::Debug for BootInformation {
         }
 
         if let Some(elf_sections_tag) = self.elf_sections_tag() {
-            let string_table = elf_sections_tag.string_table();
             writeln!(f, "kernel sections:")?;
             for s in elf_sections_tag.sections() {
                 writeln!(f, "    name: {:15}, S: {:#08X}, E: {:#08X}, L: {:#08X}, F: {:#04X}",
-                    string_table.section_name(s), s.start_address(),
+                    s.name(), s.start_address(),
                     s.start_address() + s.size(), s.size(), s.flags().bits())?;
             }
         }
@@ -500,53 +508,51 @@ mod tests {
         assert_eq!(addr + bytes.len(), bi.end_address());
         assert_eq!(bytes.len(), bi.total_size() as usize);
         let es = bi.elf_sections_tag().unwrap();
-        let st = es.string_table();
-        assert_eq!(string_addr, st as *const _ as u64);
         let mut s = es.sections();
         let s1 = s.next().unwrap();
-        assert_eq!(".rodata", st.section_name(s1));
+        assert_eq!(".rodata", s1.name());
         assert_eq!(0xFFFF_8000_0010_0000, s1.start_address());
         assert_eq!(0xFFFF_8000_0010_3000, s1.end_address());
         assert_eq!(0x0000_0000_0000_3000, s1.size());
         assert_eq!(ELF_SECTION_ALLOCATED, s1.flags());
         assert_eq!(ElfSectionType::ProgramSection, s1.section_type());
         let s2 = s.next().unwrap();
-        assert_eq!(".text", st.section_name(s2));
+        assert_eq!(".text", s2.name());
         assert_eq!(0xFFFF_8000_0010_3000, s2.start_address());
         assert_eq!(0xFFFF_8000_0010_C000, s2.end_address());
         assert_eq!(0x0000_0000_0000_9000, s2.size());
         assert_eq!(ELF_SECTION_EXECUTABLE | ELF_SECTION_ALLOCATED, s2.flags());
         assert_eq!(ElfSectionType::ProgramSection, s2.section_type());
         let s3 = s.next().unwrap();
-        assert_eq!(".data", st.section_name(s3));
+        assert_eq!(".data", s3.name());
         assert_eq!(0xFFFF_8000_0010_C000, s3.start_address());
         assert_eq!(0xFFFF_8000_0010_E000, s3.end_address());
         assert_eq!(0x0000_0000_0000_2000, s3.size());
         assert_eq!(ELF_SECTION_ALLOCATED | ELF_SECTION_WRITABLE, s3.flags());
         assert_eq!(ElfSectionType::ProgramSection, s3.section_type());
         let s4 = s.next().unwrap();
-        assert_eq!(".bss", st.section_name(s4));
+        assert_eq!(".bss", s4.name());
         assert_eq!(0xFFFF_8000_0010_E000, s4.start_address());
         assert_eq!(0xFFFF_8000_0011_3000, s4.end_address());
         assert_eq!(0x0000_0000_0000_5000, s4.size());
         assert_eq!(ELF_SECTION_ALLOCATED | ELF_SECTION_WRITABLE, s4.flags());
         assert_eq!(ElfSectionType::Uninitialized, s4.section_type());
         let s5 = s.next().unwrap();
-        assert_eq!(".data.rel.ro", st.section_name(s5));
+        assert_eq!(".data.rel.ro", s5.name());
         assert_eq!(0xFFFF_8000_0011_3000, s5.start_address());
         assert_eq!(0xFFFF_8000_0011_3000, s5.end_address());
         assert_eq!(0x0000_0000_0000_0000, s5.size());
         assert_eq!(ELF_SECTION_ALLOCATED | ELF_SECTION_WRITABLE, s5.flags());
         assert_eq!(ElfSectionType::ProgramSection, s5.section_type());
         let s6 = s.next().unwrap();
-        assert_eq!(".symtab", st.section_name(s6));
+        assert_eq!(".symtab", s6.name());
         assert_eq!(0x0000_0000_0011_3000, s6.start_address());
         assert_eq!(0x0000_0000_0011_5BE0, s6.end_address());
         assert_eq!(0x0000_0000_0000_2BE0, s6.size());
         assert_eq!(ElfSectionFlags::empty(), s6.flags());
         assert_eq!(ElfSectionType::LinkerSymbolTable, s6.section_type());
         let s7 = s.next().unwrap();
-        assert_eq!(".strtab", st.section_name(s7));
+        assert_eq!(".strtab", s7.name());
         assert_eq!(0x0000_0000_0011_5BE0, s7.start_address());
         assert_eq!(0x0000_0000_0011_9371, s7.end_address());
         assert_eq!(0x0000_0000_0000_3791, s7.size());