@@ -12,6 +12,11 @@
 - Added `NvmExpressPassThruProtocol`.
 - Added `AtaPassThruProtocol`.
 - Added `DevicePathUtilitiesProtocol`.
+- Added `length()` to `DevicePathProtocol` properly constructing the `u16` value
+
+## Changed
+- `DevicePathHeader` now derives
+`Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash`
 
 
 # uefi-raw - 0.10.0 (2025-02-07)

@@ -13,17 +13,24 @@ pub use device_path_gen::{acpi, bios_boot_spec, end, hardware, media, messaging}
 ///
 /// Note that the fields in this struct define the header at the start of each
 /// node; a device path is typically larger than these four bytes.
-#[derive(Debug)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 #[repr(C)]
 pub struct DevicePathProtocol {
 pub major_type: DeviceType,
 pub sub_type: DeviceSubType,
+/// Total length of the type including the fixed header as u16 in LE order.
  pub length: [u8; 2],
 // followed by payload (dynamically sized)
 }
 
 impl DevicePathProtocol {
 pub const GUID: Guid = guid!("09576e91-6d3f-11d2-8e39-00a0c969723b");
+
+/// Returns the total length of that type as `u16`.
+ #[must_use]
+pub const fn length(&self) -> u16 {
+u16::from_le_bytes(self.length)
+}
 }
 
 newtype_enum! {
@@ -252,3 +259,17 @@ pub struct DevicePathUtilitiesProtocol {
 impl DevicePathUtilitiesProtocol {
 pub const GUID: Guid = guid!("0379be4e-d706-437d-b037-edb82fb772a4");
 }
+
+#[cfg(test)]
+mod tests {
+use super::*;
+use core::mem;
+
+/// Test that ensures the struct is packed. Thus, we don't need to
+ /// explicitly specify `packed`.
+ #[test]
+fn abi() {
+assert_eq!(mem::size_of::<DevicePathProtocol>(), 4);
+assert_eq!(mem::align_of::<DevicePathProtocol>(), 1);
+}
+}

@@ -22,6 +22,8 @@
 `proto::device_path::text` to `proto::device_path`.
 - **Breaking:** `exit_boot_services` now consumes a `Option<MemoryType>` which
 defaults to the recommended value of `MemoryType::LOADER_DATA`.
+- **Breaking:** Removed duplication in `DevicePathHeader`. This change however
+not affect many users.
 - `boot::memory_map()` will never return `Status::BUFFER_TOO_SMALL` from now on,
 as this is considered a hard internal error where users can't do anything
 about it anyway. It will panic instead.

@@ -225,7 +225,7 @@ pub unsafe trait BuildNode {
 
 unsafe impl BuildNode for &DevicePathNode {
 fn size_in_bytes(&self) -> Result<u16, BuildError> {
-Ok(self.header.length)
+Ok(self.header.length())
 }
 
 fn write_data(&self, out: &mut [MaybeUninit<u8>]) {

@@ -89,8 +89,9 @@ use crate::mem::PoolAllocation;
 use crate::proto::{unsafe_protocol, ProtocolPointer};
 use core::ffi::c_void;
 use core::fmt::{self, Debug, Display, Formatter};
-use core::ops::Deref;
+use core::ops::{Deref, DerefMut};
 use ptr_meta::Pointee;
+use uefi_raw::protocol::device_path::DevicePathProtocol;
 
 #[cfg(feature = "alloc")]
 use {
@@ -137,15 +138,8 @@ impl Deref for PoolDevicePathNode {
 
 /// Header that appears at the start of every [`DevicePathNode`].
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-#[repr(C, packed)]
-pub struct DevicePathHeader {
-/// Type of device
- pub device_type: DeviceType,
-/// Sub type of device
- pub sub_type: DeviceSubType,
-/// Size (in bytes) of the [`DevicePathNode`], including this header.
- pub length: u16,
-}
+#[repr(transparent)]
+pub struct DevicePathHeader(DevicePathProtocol);
 
 impl<'a> TryFrom<&'a [u8]> for &'a DevicePathHeader {
 type Error = ByteConversionError;
@@ -159,6 +153,20 @@ impl<'a> TryFrom<&'a [u8]> for &'a DevicePathHeader {
 }
 }
 
+impl Deref for DevicePathHeader {
+type Target = DevicePathProtocol;
+
+fn deref(&self) -> &Self::Target {
+&self.0
+}
+}
+
+impl DerefMut for DevicePathHeader {
+fn deref_mut(&mut self) -> &mut Self::Target {
+&mut self.0
+}
+}
+
 /// A single node within a [`DevicePath`].
 ///
 /// Each node starts with a [`DevicePathHeader`]. The rest of the data
@@ -202,7 +210,7 @@ impl DevicePathNode {
 pub unsafe fn from_ffi_ptr<'a>(ptr: *const FfiDevicePath) -> &'a Self {
 let header = unsafe { *ptr.cast::<DevicePathHeader>() };
 
-let data_len = usize::from(header.length) - size_of::<DevicePathHeader>();
+let data_len = usize::from(header.length()) - size_of::<DevicePathHeader>();
 unsafe { &*ptr_meta::from_raw_parts(ptr.cast(), data_len) }
 }
 
@@ -216,25 +224,25 @@ impl DevicePathNode {
 /// Type of device
  #[must_use]
 pub const fn device_type(&self) -> DeviceType {
-self.header.device_type
+self.header.0.major_type
 }
 
 /// Sub type of device
  #[must_use]
 pub const fn sub_type(&self) -> DeviceSubType {
-self.header.sub_type
+self.header.0.sub_type
 }
 
 /// Tuple of the node's type and subtype.
  #[must_use]
 pub const fn full_type(&self) -> (DeviceType, DeviceSubType) {
-(self.header.device_type, self.header.sub_type)
+(self.header.0.major_type, self.header.0.sub_type)
 }
 
 /// Size (in bytes) of the full [`DevicePathNode`], including the header.
  #[must_use]
 pub const fn length(&self) -> u16 {
-self.header.length
+self.header.0.length()
 }
 
 /// True if this node ends an entire [`DevicePath`].
@@ -297,7 +305,7 @@ impl<'a> TryFrom<&'a [u8]> for &'a DevicePathNode {
 
 fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
 let dp = <&DevicePathHeader>::try_from(bytes)?;
-if usize::from(dp.length) <= bytes.len() {
+if usize::from(dp.length()) <= bytes.len() {
 unsafe { Ok(DevicePathNode::from_ffi_ptr(bytes.as_ptr().cast())) }
 } else {
 Err(ByteConversionError::InvalidLength)

@@ -473,12 +473,13 @@ impl Node {
 assert_eq!(size, out.len());
 
 let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out);
+let length = u16::try_from(size).unwrap();
 unsafe {
-out_ptr.cast::<DevicePathHeader>().write_unaligned(DevicePathHeader {
-device_type: DeviceType::#device_type,
+out_ptr.cast::<DevicePathHeader>().write_unaligned(DevicePathHeader(device_path::DevicePathProtocol {
+major_type: DeviceType::#device_type,
 sub_type: DeviceSubType::#sub_type,
-length: u16::try_from(size).unwrap(),
-});
+length: length.to_le_bytes(),
+}));
 #(#copy_stmts)*
 }
 }