Merge branch 'main' into next

Author: phil-opp

Cargo.lock

@@ -20,6 +20,12 @@ rand = { version = "0.8.4", default-features = false }
 rand_hc = "0.3.1"
 
 [dependencies.noto-sans-mono-bitmap]
-version = "0.1.2"
+version = "0.2.0"
 default-features = false
-features = ["regular", "size_14"]
+features = [
+    "regular",
+    "size_16",
+    "unicode-basic-latin",
+    # required for the fallback char '�'
+    "unicode-specials",
+]

common/Cargo.toml

@@ -127,6 +127,14 @@ where
             }
         }
 
+        // Mark some memory regions as read-only after relocations have been
+        // applied.
+        for program_header in self.elf_file.program_iter() {
+            if let Type::GnuRelro = program_header.get_type()? {
+                self.inner.handle_relro_segment(program_header);
+            }
+        }
+
         self.inner.remove_copied_flags(&self.elf_file).unwrap();
 
         Ok(tls_template)
@@ -496,6 +504,44 @@ where
 
         Ok(())
     }
+
+    /// Mark a region of memory indicated by a GNU_RELRO segment as read-only.
+    ///
+    /// This is a security mitigation used to protect memory regions that
+    /// need to be writable while applying relocations, but should never be
+    /// written to after relocations have been applied.
+    fn handle_relro_segment(&mut self, program_header: ProgramHeader) {
+        let start = self.virtual_address_offset + program_header.virtual_addr();
+        let end = start + program_header.mem_size();
+        let start = VirtAddr::new(start);
+        let end = VirtAddr::new(end);
+        let start_page = Page::containing_address(start);
+        let end_page = Page::containing_address(end - 1u64);
+        for page in Page::<Size4KiB>::range_inclusive(start_page, end_page) {
+            // Translate the page and get the flags.
+            let res = self.page_table.translate(page.start_address());
+            let flags = match res {
+                TranslateResult::Mapped {
+                    frame: _,
+                    offset: _,
+                    flags,
+                } => flags,
+                TranslateResult::NotMapped | TranslateResult::InvalidFrameAddress(_) => {
+                    unreachable!("has the elf file not been mapped correctly?")
+                }
+            };
+
+            if flags.contains(Flags::WRITABLE) {
+                // Remove the WRITABLE flag.
+                unsafe {
+                    self.page_table
+                        .update_flags(page, flags & !Flags::WRITABLE)
+                        .unwrap()
+                        .ignore();
+                }
+            }
+        }
+    }
 }
 
 /// Check that the virtual offset belongs to a load segment.

common/src/load_kernel.rs

@@ -4,7 +4,10 @@ use core::{
     fmt::{self, Write},
     ptr,
 };
-use noto_sans_mono_bitmap::{get_bitmap, get_bitmap_width, BitmapChar, BitmapHeight, FontWeight};
+use font_constants::BACKUP_CHAR;
+use noto_sans_mono_bitmap::{
+    get_raster, get_raster_width, FontWeight, RasterHeight, RasterizedChar,
+};
 use spinning_top::Spinlock;
 
 /// The global logger instance used for the `log` crate.
@@ -14,9 +17,42 @@ pub static LOGGER: OnceCell<LockedLogger> = OnceCell::uninit();
 pub struct LockedLogger(Spinlock<Logger>);
 
 /// Additional vertical space between lines
-const LINE_SPACING: usize = 0;
-/// Additional vertical space between separate log messages
-const LOG_SPACING: usize = 2;
+const LINE_SPACING: usize = 2;
+/// Additional horizontal space between characters.
+const LETTER_SPACING: usize = 0;
+
+/// Padding from the border. Prevent that font is too close to border.
+const BORDER_PADDING: usize = 1;
+
+/// Constants for the usage of the [`noto_sans_mono_bitmap`] crate.
+mod font_constants {
+    use super::*;
+
+    /// Height of each char raster. The font size is ~0.84% of this. Thus, this is the line height that
+    /// enables multiple characters to be side-by-side and appear optically in one line in a natural way.
+    pub const CHAR_RASTER_HEIGHT: RasterHeight = RasterHeight::Size16;
+
+    /// The width of each single symbol of the mono space font.
+    pub const CHAR_RASTER_WIDTH: usize = get_raster_width(FontWeight::Regular, CHAR_RASTER_HEIGHT);
+
+    /// Backup character if a desired symbol is not available by the font.
+    /// The '�' character requires the feature "unicode-specials".
+    pub const BACKUP_CHAR: char = '�';
+
+    pub const FONT_WEIGHT: FontWeight = FontWeight::Regular;
+}
+
+/// Returns the raster of the given char or the raster of [`font_constants::BACKUP_CHAR`].
+fn get_char_raster(c: char) -> RasterizedChar {
+    fn get(c: char) -> Option<RasterizedChar> {
+        get_raster(
+            c,
+            font_constants::FONT_WEIGHT,
+            font_constants::CHAR_RASTER_HEIGHT,
+        )
+    }
+    get(c).unwrap_or(get(BACKUP_CHAR).expect("Should get raster of backup char."))
+}
 
 impl LockedLogger {
     /// Create a new instance that logs to the given framebuffer.
@@ -39,8 +75,7 @@ impl log::Log for LockedLogger {
 
     fn log(&self, record: &log::Record) {
         let mut logger = self.0.lock();
-        writeln!(logger, "{}:    {}", record.level(), record.args()).unwrap();
-        logger.add_vspace(LOG_SPACING);
+        writeln!(logger, "{:5}: {}", record.level(), record.args()).unwrap();
     }
 
     fn flush(&self) {}
@@ -68,22 +103,18 @@ impl Logger {
     }
 
     fn newline(&mut self) {
-        self.y_pos += 14 + LINE_SPACING;
+        self.y_pos += font_constants::CHAR_RASTER_HEIGHT.val() + LINE_SPACING;
         self.carriage_return()
     }
 
-    fn add_vspace(&mut self, space: usize) {
-        self.y_pos += space;
-    }
-
     fn carriage_return(&mut self) {
-        self.x_pos = 0;
+        self.x_pos = BORDER_PADDING;
     }
 
-    /// Erases all text on the screen.
+    /// Erases all text on the screen. Resets `self.x_pos` and `self.y_pos`.
     pub fn clear(&mut self) {
-        self.x_pos = 0;
-        self.y_pos = 0;
+        self.x_pos = BORDER_PADDING;
+        self.y_pos = BORDER_PADDING;
         self.framebuffer.fill(0);
     }
 
@@ -95,30 +126,36 @@ impl Logger {
         self.info.height
     }
 
+    /// Writes a single char to the framebuffer. Takes care of special control characters, such as
+    /// newlines and carriage returns.
     fn write_char(&mut self, c: char) {
         match c {
             '\n' => self.newline(),
             '\r' => self.carriage_return(),
             c => {
-                let bitmap_char = get_bitmap(c, FontWeight::Regular, BitmapHeight::Size14).unwrap();
-                if self.x_pos + bitmap_char.width() > self.width() {
+                let new_xpos = self.x_pos + font_constants::CHAR_RASTER_WIDTH;
+                if new_xpos >= self.width() {
                     self.newline();
                 }
-                if self.y_pos + bitmap_char.height() > self.height() {
+                let new_ypos =
+                    self.y_pos + font_constants::CHAR_RASTER_HEIGHT.val() + BORDER_PADDING;
+                if new_ypos >= self.height() {
                     self.clear();
                 }
-                self.write_rendered_char(bitmap_char);
+                self.write_rendered_char(get_char_raster(c));
             }
         }
     }
 
-    fn write_rendered_char(&mut self, rendered_char: BitmapChar) {
-        for (y, row) in rendered_char.bitmap().iter().enumerate() {
+    /// Prints a rendered char into the framebuffer.
+    /// Updates `self.x_pos`.
+    fn write_rendered_char(&mut self, rendered_char: RasterizedChar) {
+        for (y, row) in rendered_char.raster().iter().enumerate() {
             for (x, byte) in row.iter().enumerate() {
                 self.write_pixel(self.x_pos + x, self.y_pos + y, *byte);
             }
         }
-        self.x_pos += rendered_char.width();
+        self.x_pos += rendered_char.width() + LETTER_SPACING;
     }
 
     fn write_pixel(&mut self, x: usize, y: usize, intensity: u8) {