rust-osdev
diff --git a/‎CHANGELOG.md‎
Lines changed: 13 additions & 1 deletion b/‎CHANGELOG.md‎
Lines changed: 13 additions & 1 deletion
diff --git a/‎src/data_types/mod.rs‎
Lines changed: 73 additions & 0 deletions b/‎src/data_types/mod.rs‎
Lines changed: 73 additions & 0 deletions
diff --git a/‎src/lib.rs‎
Lines changed: 1 addition & 0 deletions b/‎src/lib.rs‎
Lines changed: 1 addition & 0 deletions
@@ -13,6 +13,8 @@
   underlying slice.
 - Added `LoadedImage::load_options_as_bytes` and
   `LoadedImage::load_options_as_cstr16`.
+- Added `Align::offset_up_to_alignment`, `Align::round_up_to_alignment`,
+  and `Align::align_buf`.
 
 ### Changed
 
@@ -21,7 +23,9 @@
   avoiding an implicit string conversion.
 - `FileInfo::new`, `FileSystemInfo::new`, and
   `FileSystemVolumeLabel::new` now take their `name` parameter as
-  `&CStr16` instead of `&str`, avoiding an implicit string conversion.
+  `&CStr16` instead of `&str`, avoiding an implicit string
+  conversion. Additionally, an unaligned storage buffer is now allowed
+  as long as it is big enough to provide an aligned subslice.
 - `LoadImage::set_load_options` now takes a `u8` pointer instead of
   `Char16`.
 
@@ -36,10 +40,18 @@
 - Removed `LoadedImage::load_options`, use
   `LoadedImage::load_options_as_bytes` or
   `LoadedImage::load_options_as_cstr16` instead.
+- Removed `NamedFileProtocolInfo`, `FileInfoHeader`,
+  `FileSystemInfoHeader`, and `FileSystemVolumeLabelHeader`. Use
+  `FileInfo`, `FileSystemInfo`, and `FileSystemVolumeLabel` instead.
 
 ### Fixed
 
 - Fixed compilation with Rust 1.60 by no longer enabling the
   `vec_spare_capacity` feature, which has been stabilized.
 - Fixed the header size calculated by `FileInfo::new` and
   `FileSystemInfo::new`.
+- Fixed incorrect alignment of the volume label field in
+  `FileSystemInfo`. This caused the beginning of the string to be
+  truncated and could result in out-of-bounds reads.
+- Fixed size check for file info types so that alignment padding is
+  taken into account. This fixes potential out-of-bounds writes.
@@ -68,6 +68,33 @@ pub trait Align {
     /// Required memory alignment for this type
     fn alignment() -> usize;
 
+    /// Calculate the offset from `val` necessary to make it aligned,
+    /// rounding up. For example, if `val` is 1 and the alignment is 8,
+    /// this will return 7. Returns 0 if `val == 0`.
+    fn offset_up_to_alignment(val: usize) -> usize {
+        assert!(Self::alignment() != 0);
+        let r = val % Self::alignment();
+        if r == 0 {
+            0
+        } else {
+            Self::alignment() - r
+        }
+    }
+
+    /// Round `val` up so that it is aligned.
+    fn round_up_to_alignment(val: usize) -> usize {
+        val + Self::offset_up_to_alignment(val)
+    }
+
+    /// Get a subslice of `buf` where the address of the first element
+    /// is aligned. Returns `None` if no element of the buffer is
+    /// aligned.
+    fn align_buf(buf: &mut [u8]) -> Option<&mut [u8]> {
+        let addr = buf.as_ptr() as usize;
+        let offset = Self::offset_up_to_alignment(addr);
+        buf.get_mut(offset..)
+    }
+
     /// Assert that some storage is correctly aligned for this type
     fn assert_aligned(storage: &mut [u8]) {
         if !storage.is_empty() {
@@ -97,3 +124,49 @@ pub use self::strs::{CStr16, CStr8, FromSliceWithNulError, FromStrWithBufError};
 mod owned_strs;
 #[cfg(feature = "exts")]
 pub use self::owned_strs::{CString16, FromStrError};
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_alignment() {
+        struct X {}
+
+        impl Align for X {
+            fn alignment() -> usize {
+                4
+            }
+        }
+
+        assert_eq!(X::offset_up_to_alignment(0), 0);
+        assert_eq!(X::offset_up_to_alignment(1), 3);
+        assert_eq!(X::offset_up_to_alignment(2), 2);
+        assert_eq!(X::offset_up_to_alignment(3), 1);
+        assert_eq!(X::offset_up_to_alignment(4), 0);
+        assert_eq!(X::offset_up_to_alignment(5), 3);
+        assert_eq!(X::offset_up_to_alignment(6), 2);
+        assert_eq!(X::offset_up_to_alignment(7), 1);
+        assert_eq!(X::offset_up_to_alignment(8), 0);
+
+        assert_eq!(X::round_up_to_alignment(0), 0);
+        assert_eq!(X::round_up_to_alignment(1), 4);
+        assert_eq!(X::round_up_to_alignment(2), 4);
+        assert_eq!(X::round_up_to_alignment(3), 4);
+        assert_eq!(X::round_up_to_alignment(4), 4);
+        assert_eq!(X::round_up_to_alignment(5), 8);
+        assert_eq!(X::round_up_to_alignment(6), 8);
+        assert_eq!(X::round_up_to_alignment(7), 8);
+        assert_eq!(X::round_up_to_alignment(8), 8);
+
+        // Get an intentionally mis-aligned buffer.
+        let mut buffer = [0u8; 16];
+        let mut buffer = &mut buffer[..];
+        if (buffer.as_ptr() as usize) % X::alignment() == 0 {
+            buffer = &mut buffer[1..];
+        }
+
+        let buffer = X::align_buf(buffer).unwrap();
+        X::assert_aligned(buffer);
+    }
+}
@@ -29,6 +29,7 @@
 #![feature(try_trait_v2)]
 #![feature(abi_efiapi)]
 #![feature(negative_impls)]
+#![feature(ptr_metadata)]
 #![no_std]
 // Enable some additional warnings and lints.
 #![warn(missing_docs, unused)]