Merge remote-tracking branch 'origin/main' into Iommu

Author: PelleKrab

uefi/CHANGELOG.md

@@ -19,6 +19,7 @@
   implements `Display`.
 - Added `Handle::component_name()` and `Handle::device_path()` to simplify the
   common use-case of querying more information about a handle.
+- Added `fs::path::Path::join()`.
 
 ## Changed
 - export all `text::{input, output}::*` types

uefi/src/fs/path/path.rs

@@ -85,6 +85,14 @@ impl Path {
     pub const fn is_empty(&self) -> bool {
         self.to_cstr16().is_empty()
     }
+
+    /// Creates an owned [`PathBuf`] with `path` adjoined to `self`.
+    #[must_use]
+    pub fn join<P: AsRef<Self>>(&self, path: P) -> PathBuf {
+        let mut buf = self.to_path_buf();
+        buf.push(path);
+        buf
+    }
 }
 
 impl Display for Path {
@@ -294,4 +302,19 @@ mod tests {
         assert_ne!(path1, path3);
         assert_ne!(path3, path1);
     }
+
+    #[test]
+    fn join() {
+        let path1 = Path::new(cstr16!(r"a\b"));
+        let path2 = Path::new(cstr16!(r"c\d"));
+        let path3 = Path::new(cstr16!(r"a\b\c\d"));
+
+        assert_eq!(path1.join(path2), path3.to_path_buf());
+
+        let pathbuf1 = path1.to_path_buf();
+        let pathbuf2 = path2.to_path_buf();
+        let pathbuf3 = path3.to_path_buf();
+
+        assert_eq!(pathbuf1.join(pathbuf2), pathbuf3);
+    }
 }

uefi/src/proto/console/serial.rs

@@ -4,7 +4,7 @@
 
 use crate::proto::unsafe_protocol;
 use crate::{Error, Result, Status, StatusExt};
-use core::fmt::Write;
+use core::fmt;
 use uefi_raw::protocol::console::serial::{
     SerialIoProtocol, SerialIoProtocol_1_1, SerialIoProtocolRevision,
 };
@@ -131,28 +131,66 @@ impl Serial {
         unsafe { (self.0.set_control_bits)(&mut self.0, bits) }.to_result()
     }
 
-    /// Reads data from this device.
+    /// Reads data from the device. This function has the raw semantics of the
+    /// underlying UEFI protocol.
     ///
-    /// This operation will block until the buffer has been filled with data or
-    /// an error occurs. In the latter case, the error will indicate how many
-    /// bytes were actually read from the device.
-    pub fn read(&mut self, data: &mut [u8]) -> Result<(), usize> {
-        let mut buffer_size = data.len();
-        unsafe { (self.0.read)(&mut self.0, &mut buffer_size, data.as_mut_ptr()) }.to_result_with(
-            || debug_assert_eq!(buffer_size, data.len()),
+    /// The function will read bytes until either the buffer is full or a
+    /// timeout or overrun error occurs.
+    ///
+    /// # Arguments
+    ///
+    /// - `buffer`: buffer to fill
+    ///
+    /// # Tips
+    ///
+    /// Consider setting non-default properties via [`Self::set_attributes`]
+    /// and [`Self::set_control_bits`] matching your use-case. For more info,
+    /// please read the general [documentation](Self) of the protocol.
+    ///
+    /// # Errors
+    ///
+    /// - [`Status::DEVICE_ERROR`]: serial device reported an error
+    /// - [`Status::TIMEOUT`]: operation was stopped due to a timeout or overrun
+    pub fn read(&mut self, buffer: &mut [u8]) -> Result<(), usize /* read bytes on timeout*/> {
+        let mut buffer_size = buffer.len();
+        unsafe { (self.0.read)(&mut self.0, &mut buffer_size, buffer.as_mut_ptr()) }.to_result_with(
+            || {
+                // By spec: Either reads all requested bytes (and blocks) or
+                // returns early with an error.
+                assert_eq!(buffer_size, buffer.len())
+            },
             |_| buffer_size,
         )
     }
 
-    /// Writes data to this device.
+    /// Writes data to this device. This function has the raw semantics of the
+    /// underlying UEFI protocol.
+    ///
+    /// The function will try to write all provided bytes in the configured
+    /// timeout.
+    ///
+    /// # Arguments
+    ///
+    /// - `data`: bytes to write
+    ///
+    /// # Tips
+    ///
+    /// Consider setting non-default properties via [`Self::set_attributes`]
+    /// and [`Self::set_control_bits`] matching your use-case. For more info,
+    /// please read the general [documentation](Self) of the protocol.
+    ///
+    /// # Errors
     ///
-    /// This operation will block until the data has been fully written or an
-    /// error occurs. In the latter case, the error will indicate how many bytes
-    /// were actually written to the device.
-    pub fn write(&mut self, data: &[u8]) -> Result<(), usize> {
+    /// - [`Status::DEVICE_ERROR`]: serial device reported an error
+    /// - [`Status::TIMEOUT`]: data write was stopped due to a timeout
+    pub fn write(&mut self, data: &[u8]) -> Result<(), usize /* bytes written on timeout */> {
         let mut buffer_size = data.len();
         unsafe { (self.0.write)(&mut self.0, &mut buffer_size, data.as_ptr()) }.to_result_with(
-            || debug_assert_eq!(buffer_size, data.len()),
+            || {
+                // By spec: Either reads all requested bytes (and blocks) or
+                // returns early with an error.
+                assert_eq!(buffer_size, data.len())
+            },
             |_| buffer_size,
         )
     }
@@ -198,8 +236,8 @@ impl Serial {
     }
 }
 
-impl Write for Serial {
-    fn write_str(&mut self, s: &str) -> core::fmt::Result {
-        self.write(s.as_bytes()).map_err(|_| core::fmt::Error)
+impl fmt::Write for Serial {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.write(s.as_bytes()).map(|_| ()).map_err(|_| fmt::Error)
     }
 }

uefi/src/proto/device_path/mod.rs

@@ -111,6 +111,7 @@ use crate::proto::{ProtocolPointer, unsafe_protocol};
 use core::ffi::c_void;
 use core::fmt::{self, Debug, Display, Formatter};
 use core::ops::Deref;
+use core::ptr;
 use ptr_meta::Pointee;
 use uefi_raw::protocol::device_path::DevicePathProtocol;
 #[cfg(feature = "alloc")]
@@ -564,8 +565,7 @@ impl DevicePath {
     /// Cast to a [`FfiDevicePath`] pointer.
     #[must_use]
     pub const fn as_ffi_ptr(&self) -> *const FfiDevicePath {
-        let p = self as *const Self;
-        p.cast()
+        ptr::from_ref(self).cast()
     }
 
     /// Get an iterator over the [`DevicePathInstance`]s in this path.

uefi/src/proto/rng.rs

@@ -52,7 +52,7 @@ impl Rng {
 
         let algo = match algorithm.as_ref() {
             None => ptr::null(),
-            Some(algo) => algo as *const RngAlgorithmType,
+            Some(algo) => ptr::from_ref(algo),
         };
 
         unsafe {