diff --git a/uefi/src/allocator.rs b/uefi/src/allocator.rs
index 223943609..d030d55ed 100644
--- a/uefi/src/allocator.rs
+++ b/uefi/src/allocator.rs
@@ -90,9 +90,11 @@ unsafe impl GlobalAlloc for Allocator {
// write is appropriately aligned for a `*mut u8` pointer because
// `align_ptr` is aligned, and alignments are always powers of two
// (as enforced by the `Layout` type).
- let aligned_ptr = full_alloc_ptr.add(offset);
- (aligned_ptr.cast::<*mut u8>()).sub(1).write(full_alloc_ptr);
- aligned_ptr
+ unsafe {
+ let aligned_ptr = full_alloc_ptr.add(offset);
+ (aligned_ptr.cast::<*mut u8>()).sub(1).write(full_alloc_ptr);
+ aligned_ptr
+ }
} else {
// The requested alignment is less than or equal to eight, and
// `allocate_pool` always provides eight-byte alignment, so we can
@@ -108,13 +110,13 @@ unsafe impl GlobalAlloc for Allocator {
if layout.align() > 8 {
// Retrieve the pointer to the full allocation that was packed right
// before the aligned allocation in `alloc`.
- ptr = (ptr as *const *mut u8).sub(1).read();
+ ptr = unsafe { (ptr as *const *mut u8).sub(1).read() };
}
// OK to unwrap: `ptr` is required to be a valid allocation by the trait API.
let ptr = NonNull::new(ptr).unwrap();
// Warning: this will panic after exiting boot services.
- boot::free_pool(ptr).unwrap();
+ unsafe { boot::free_pool(ptr) }.unwrap();
}
}
diff --git a/uefi/src/boot.rs b/uefi/src/boot.rs
index e5de81f53..4c44bef55 100644
--- a/uefi/src/boot.rs
+++ b/uefi/src/boot.rs
@@ -116,7 +116,7 @@ pub unsafe fn raise_tpl(tpl: Tpl) -> TplGuard {
let bt = unsafe { bt.as_ref() };
TplGuard {
- old_tpl: (bt.raise_tpl)(tpl),
+ old_tpl: unsafe { (bt.raise_tpl)(tpl) },
}
}
@@ -381,15 +381,17 @@ pub unsafe fn create_event(
// Safety: the argument types of the function pointers are defined
// differently, but are compatible and can be safely transmuted.
- let notify_fn: Option<uefi_raw::table::boot::EventNotifyFn> = mem::transmute(notify_fn);
+ let notify_fn: Option<uefi_raw::table::boot::EventNotifyFn> =
+ unsafe { mem::transmute(notify_fn) };
let notify_ctx = opt_nonnull_to_ptr(notify_ctx);
// Now we're ready to call UEFI
- (bt.create_event)(event_ty, notify_tpl, notify_fn, notify_ctx, &mut event).to_result_with_val(
- // OK to unwrap: event is non-null for Status::SUCCESS.
- || Event::from_ptr(event).unwrap(),
- )
+ unsafe { (bt.create_event)(event_ty, notify_tpl, notify_fn, notify_ctx, &mut event) }
+ .to_result_with_val(
+ // OK to unwrap: event is non-null for Status::SUCCESS.
+ || unsafe { Event::from_ptr(event) }.unwrap(),
+ )
}
/// Creates an event in an event group.
@@ -451,19 +453,22 @@ pub unsafe fn create_event_ex(
// Safety: the argument types of the function pointers are defined
// differently, but are compatible and can be safely transmuted.
- let notify_fn: Option<uefi_raw::table::boot::EventNotifyFn> = mem::transmute(notify_fn);
-
- (bt.create_event_ex)(
- event_type,
- notify_tpl,
- notify_fn,
- opt_nonnull_to_ptr(notify_ctx),
- opt_nonnull_to_ptr(event_group),
- &mut event,
- )
+ let notify_fn: Option<uefi_raw::table::boot::EventNotifyFn> =
+ unsafe { mem::transmute(notify_fn) };
+
+ unsafe {
+ (bt.create_event_ex)(
+ event_type,
+ notify_tpl,
+ notify_fn,
+ opt_nonnull_to_ptr(notify_ctx),
+ opt_nonnull_to_ptr(event_group),
+ &mut event,
+ )
+ }
.to_result_with_val(
// OK to unwrap: event is non-null for Status::SUCCESS.
- || Event::from_ptr(event).unwrap(),
+ || unsafe { Event::from_ptr(event) }.unwrap(),
)
}
@@ -696,13 +701,15 @@ pub unsafe fn install_protocol_interface(
let bt = unsafe { bt.as_ref() };
let mut handle = Handle::opt_to_ptr(handle);
- ((bt.install_protocol_interface)(
- &mut handle,
- protocol,
- InterfaceType::NATIVE_INTERFACE,
- interface,
- ))
- .to_result_with_val(|| Handle::from_ptr(handle).unwrap())
+ unsafe {
+ (bt.install_protocol_interface)(
+ &mut handle,
+ protocol,
+ InterfaceType::NATIVE_INTERFACE,
+ interface,
+ )
+ }
+ .to_result_with_val(|| unsafe { Handle::from_ptr(handle) }.unwrap())
}
/// Reinstalls a protocol interface on a device handle. `old_interface` is replaced with `new_interface`.
@@ -730,8 +737,10 @@ pub unsafe fn reinstall_protocol_interface(
let bt = boot_services_raw_panicking();
let bt = unsafe { bt.as_ref() };
- (bt.reinstall_protocol_interface)(handle.as_ptr(), protocol, old_interface, new_interface)
- .to_result()
+ unsafe {
+ (bt.reinstall_protocol_interface)(handle.as_ptr(), protocol, old_interface, new_interface)
+ }
+ .to_result()
}
/// Removes a protocol interface from a device handle.
@@ -757,7 +766,7 @@ pub unsafe fn uninstall_protocol_interface(
let bt = boot_services_raw_panicking();
let bt = unsafe { bt.as_ref() };
- (bt.uninstall_protocol_interface)(handle.as_ptr(), protocol, interface).to_result()
+ unsafe { (bt.uninstall_protocol_interface)(handle.as_ptr(), protocol, interface).to_result() }
}
/// Registers `event` to be signaled whenever a protocol interface is registered for
@@ -1035,19 +1044,21 @@ pub unsafe fn open_protocol<P: ProtocolPointer + ?Sized>(
let bt = unsafe { bt.as_ref() };
let mut interface = ptr::null_mut();
- (bt.open_protocol)(
- params.handle.as_ptr(),
- &P::GUID,
- &mut interface,
- params.agent.as_ptr(),
- Handle::opt_to_ptr(params.controller),
- attributes as u32,
- )
+ unsafe {
+ (bt.open_protocol)(
+ params.handle.as_ptr(),
+ &P::GUID,
+ &mut interface,
+ params.agent.as_ptr(),
+ Handle::opt_to_ptr(params.controller),
+ attributes as u32,
+ )
+ }
.to_result_with_val(|| {
let interface = if interface.is_null() {
None
} else {
- NonNull::new(P::mut_ptr_from_ffi(interface))
+ NonNull::new(unsafe { P::mut_ptr_from_ffi(interface) })
};
ScopedProtocol {
interface,
@@ -1220,12 +1231,14 @@ pub unsafe fn exit(
let bt = boot_services_raw_panicking();
let bt = unsafe { bt.as_ref() };
- (bt.exit)(
- image_handle.as_ptr(),
- exit_status,
- exit_data_size,
- exit_data.cast(),
- )
+ unsafe {
+ (bt.exit)(
+ image_handle.as_ptr(),
+ exit_status,
+ exit_data_size,
+ exit_data.cast(),
+ )
+ }
}
/// Get the current memory map and exit boot services.
@@ -1241,7 +1254,7 @@ unsafe fn get_memory_map_and_exit_boot_services(buf: &mut [u8]) -> Result<Memory
// what boot services functions can be called. In UEFI 2.8 and earlier,
// only `get_memory_map` and `exit_boot_services` are allowed. Starting
// in UEFI 2.9 other memory allocation functions may also be called.
- (bt.exit_boot_services)(image_handle().as_ptr(), memory_map.map_key.0)
+ unsafe { (bt.exit_boot_services)(image_handle().as_ptr(), memory_map.map_key.0) }
.to_result_with_val(|| memory_map)
}
@@ -1344,7 +1357,7 @@ pub unsafe fn install_configuration_table(
let bt = boot_services_raw_panicking();
let bt = unsafe { bt.as_ref() };
- (bt.install_configuration_table)(guid_entry, table_ptr).to_result()
+ unsafe { (bt.install_configuration_table)(guid_entry, table_ptr) }.to_result()
}
/// Sets the watchdog timer.
diff --git a/uefi/src/data_types/strs.rs b/uefi/src/data_types/strs.rs
index 5c06a2db4..fc69782f1 100644
--- a/uefi/src/data_types/strs.rs
+++ b/uefi/src/data_types/strs.rs
@@ -143,11 +143,11 @@ impl CStr8 {
#[must_use]
pub unsafe fn from_ptr<'ptr>(ptr: *const Char8) -> &'ptr Self {
let mut len = 0;
- while *ptr.add(len) != NUL_8 {
+ while unsafe { *ptr.add(len) } != NUL_8 {
len += 1
}
let ptr = ptr.cast::<u8>();
- Self::from_bytes_with_nul_unchecked(slice::from_raw_parts(ptr, len + 1))
+ unsafe { Self::from_bytes_with_nul_unchecked(slice::from_raw_parts(ptr, len + 1)) }
}
/// Creates a CStr8 reference from bytes.
@@ -171,7 +171,7 @@ impl CStr8 {
/// null-terminated string, with no interior null bytes.
#[must_use]
pub const unsafe fn from_bytes_with_nul_unchecked(chars: &[u8]) -> &Self {
- &*(ptr::from_ref(chars) as *const Self)
+ unsafe { &*(ptr::from_ref(chars) as *const Self) }
}
/// Returns the inner pointer to this CStr8.
@@ -352,11 +352,11 @@ impl CStr16 {
#[must_use]
pub unsafe fn from_ptr<'ptr>(ptr: *const Char16) -> &'ptr Self {
let mut len = 0;
- while *ptr.add(len) != NUL_16 {
+ while unsafe { *ptr.add(len) } != NUL_16 {
len += 1
}
let ptr = ptr.cast::<u16>();
- Self::from_u16_with_nul_unchecked(slice::from_raw_parts(ptr, len + 1))
+ unsafe { Self::from_u16_with_nul_unchecked(slice::from_raw_parts(ptr, len + 1)) }
}
/// Creates a `&CStr16` from a u16 slice, stopping at the first nul character.
@@ -405,7 +405,7 @@ impl CStr16 {
/// null-terminated string, with no interior null characters.
#[must_use]
pub const unsafe fn from_u16_with_nul_unchecked(codes: &[u16]) -> &Self {
- &*(ptr::from_ref(codes) as *const Self)
+ unsafe { &*(ptr::from_ref(codes) as *const Self) }
}
/// Creates a `&CStr16` from a [`Char16`] slice, stopping at the first nul character.
@@ -455,7 +455,7 @@ impl CStr16 {
#[must_use]
pub const unsafe fn from_char16_with_nul_unchecked(chars: &[Char16]) -> &Self {
let ptr: *const [Char16] = chars;
- &*(ptr as *const Self)
+ unsafe { &*(ptr as *const Self) }
}
/// Convert a [`&str`] to a `&CStr16`, backed by a buffer.
diff --git a/uefi/src/helpers/logger.rs b/uefi/src/helpers/logger.rs
index ea03813a5..c7fdba50a 100644
--- a/uefi/src/helpers/logger.rs
+++ b/uefi/src/helpers/logger.rs
@@ -29,7 +29,7 @@ static LOGGER: Logger = Logger::new();
/// disable() on exit from UEFI boot services.
pub unsafe fn init() {
// Connect the logger to stdout.
- system::with_stdout(|stdout| {
+ system::with_stdout(|stdout| unsafe {
LOGGER.set_output(stdout);
});
diff --git a/uefi/src/lib.rs b/uefi/src/lib.rs
index bf56a3691..ebccb2430 100644
--- a/uefi/src/lib.rs
+++ b/uefi/src/lib.rs
@@ -224,6 +224,7 @@
clippy::use_self,
missing_debug_implementations,
missing_docs,
+ unsafe_op_in_unsafe_fn,
unused
)]
diff --git a/uefi/src/proto/console/gop.rs b/uefi/src/proto/console/gop.rs
index 7f3a51de3..f2e3daf0e 100644
--- a/uefi/src/proto/console/gop.rs
+++ b/uefi/src/proto/console/gop.rs
@@ -589,7 +589,7 @@ impl FrameBuffer<'_> {
#[inline]
pub unsafe fn write_byte(&mut self, index: usize, value: u8) {
debug_assert!(index < self.size, "Frame buffer accessed out of bounds");
- self.base.add(index).write_volatile(value)
+ unsafe { self.base.add(index).write_volatile(value) }
}
/// Read the i-th byte of the frame buffer
@@ -603,7 +603,7 @@ impl FrameBuffer<'_> {
#[must_use]
pub unsafe fn read_byte(&self, index: usize) -> u8 {
debug_assert!(index < self.size, "Frame buffer accessed out of bounds");
- self.base.add(index).read_volatile()
+ unsafe { self.base.add(index).read_volatile() }
}
/// Write a value in the frame buffer, starting at the i-th byte
@@ -624,8 +624,10 @@ impl FrameBuffer<'_> {
index.saturating_add(size_of::<T>()) <= self.size,
"Frame buffer accessed out of bounds"
);
- let ptr = self.base.add(index).cast::<T>();
- ptr.write_volatile(value)
+ unsafe {
+ let ptr = self.base.add(index).cast::<T>();
+ ptr.write_volatile(value)
+ }
}
/// Read a value from the frame buffer, starting at the i-th byte
@@ -647,6 +649,6 @@ impl FrameBuffer<'_> {
index.saturating_add(size_of::<T>()) <= self.size,
"Frame buffer accessed out of bounds"
);
- (self.base.add(index) as *const T).read_volatile()
+ unsafe { (self.base.add(index) as *const T).read_volatile() }
}
}
diff --git a/uefi/src/proto/debug/mod.rs b/uefi/src/proto/debug/mod.rs
index cfb0f90c9..088f061d3 100644
--- a/uefi/src/proto/debug/mod.rs
+++ b/uefi/src/proto/debug/mod.rs
@@ -98,7 +98,7 @@ impl DebugSupport {
}
// Safety: As we've validated the `processor_index`, this should always be safe
- (self.register_periodic_callback)(self, processor_index, callback).to_result()
+ unsafe { (self.register_periodic_callback)(self, processor_index, callback) }.to_result()
}
/// Registers a function to be called when a given processor exception occurs.
@@ -122,8 +122,10 @@ impl DebugSupport {
}
// Safety: As we've validated the `processor_index`, this should always be safe
- (self.register_exception_callback)(self, processor_index, callback, exception_type)
- .to_result()
+ unsafe {
+ (self.register_exception_callback)(self, processor_index, callback, exception_type)
+ }
+ .to_result()
}
/// Invalidates processor instruction cache for a memory range for a given `processor_index`.
@@ -144,7 +146,8 @@ impl DebugSupport {
// per the UEFI spec, this call should only return EFI_SUCCESS
// Safety: As we've validated the `processor_index`, this should always be safe
- (self.invalidate_instruction_cache)(self, processor_index, start, length).to_result()
+ unsafe { (self.invalidate_instruction_cache)(self, processor_index, start, length) }
+ .to_result()
}
}
diff --git a/uefi/src/proto/device_path/mod.rs b/uefi/src/proto/device_path/mod.rs
index f95d8315c..448de2c68 100644
--- a/uefi/src/proto/device_path/mod.rs
+++ b/uefi/src/proto/device_path/mod.rs
@@ -173,10 +173,10 @@ impl DevicePathNode {
/// that lifetime.
#[must_use]
pub unsafe fn from_ffi_ptr<'a>(ptr: *const FfiDevicePath) -> &'a Self {
- let header = *ptr.cast::<DevicePathHeader>();
+ let header = unsafe { *ptr.cast::<DevicePathHeader>() };
let data_len = usize::from(header.length) - size_of::<DevicePathHeader>();
- &*ptr_meta::from_raw_parts(ptr.cast(), data_len)
+ unsafe { &*ptr_meta::from_raw_parts(ptr.cast(), data_len) }
}
/// Cast to a [`FfiDevicePath`] pointer.
@@ -368,11 +368,11 @@ pub struct DevicePath {
impl ProtocolPointer for DevicePath {
unsafe fn ptr_from_ffi(ptr: *const c_void) -> *const Self {
- ptr_meta::from_raw_parts(ptr.cast(), Self::size_in_bytes_from_ptr(ptr))
+ ptr_meta::from_raw_parts(ptr.cast(), unsafe { Self::size_in_bytes_from_ptr(ptr) })
}
unsafe fn mut_ptr_from_ffi(ptr: *mut c_void) -> *mut Self {
- ptr_meta::from_raw_parts_mut(ptr.cast(), Self::size_in_bytes_from_ptr(ptr))
+ ptr_meta::from_raw_parts_mut(ptr.cast(), unsafe { Self::size_in_bytes_from_ptr(ptr) })
}
}
@@ -384,13 +384,13 @@ impl DevicePath {
let mut ptr = ptr.cast::<u8>();
let mut total_size_in_bytes: usize = 0;
loop {
- let node = DevicePathNode::from_ffi_ptr(ptr.cast::<FfiDevicePath>());
+ let node = unsafe { DevicePathNode::from_ffi_ptr(ptr.cast::<FfiDevicePath>()) };
let node_size_in_bytes = usize::from(node.length());
total_size_in_bytes += node_size_in_bytes;
if node.is_end_entire() {
break;
}
- ptr = ptr.add(node_size_in_bytes);
+ ptr = unsafe { ptr.add(node_size_in_bytes) };
}
total_size_in_bytes
@@ -434,7 +434,7 @@ impl DevicePath {
/// that lifetime.
#[must_use]
pub unsafe fn from_ffi_ptr<'a>(ptr: *const FfiDevicePath) -> &'a Self {
- &*Self::ptr_from_ffi(ptr.cast::<c_void>())
+ unsafe { &*Self::ptr_from_ffi(ptr.cast::<c_void>()) }
}
/// Cast to a [`FfiDevicePath`] pointer.
@@ -669,11 +669,15 @@ pub struct LoadedImageDevicePath(DevicePath);
impl ProtocolPointer for LoadedImageDevicePath {
unsafe fn ptr_from_ffi(ptr: *const c_void) -> *const Self {
- ptr_meta::from_raw_parts(ptr.cast(), DevicePath::size_in_bytes_from_ptr(ptr))
+ ptr_meta::from_raw_parts(ptr.cast(), unsafe {
+ DevicePath::size_in_bytes_from_ptr(ptr)
+ })
}
unsafe fn mut_ptr_from_ffi(ptr: *mut c_void) -> *mut Self {
- ptr_meta::from_raw_parts_mut(ptr.cast(), DevicePath::size_in_bytes_from_ptr(ptr))
+ ptr_meta::from_raw_parts_mut(ptr.cast(), unsafe {
+ DevicePath::size_in_bytes_from_ptr(ptr)
+ })
}
}
diff --git a/uefi/src/proto/loaded_image.rs b/uefi/src/proto/loaded_image.rs
index 02cfa1871..3ab91c4a4 100644
--- a/uefi/src/proto/loaded_image.rs
+++ b/uefi/src/proto/loaded_image.rs
@@ -150,7 +150,7 @@ impl LoadedImage {
unload: extern "efiapi" fn(image_handle: Handle) -> Status,
) {
let unload: unsafe extern "efiapi" fn(image_handle: uefi_raw::Handle) -> uefi_raw::Status =
- mem::transmute(unload);
+ unsafe { mem::transmute(unload) };
self.0.unload = Some(unload);
}
diff --git a/uefi/src/proto/media/disk.rs b/uefi/src/proto/media/disk.rs
index 80abd8c5a..d3b8fa0ec 100644
--- a/uefi/src/proto/media/disk.rs
+++ b/uefi/src/proto/media/disk.rs
@@ -130,8 +130,10 @@ impl DiskIo2 {
buffer: *mut u8,
) -> Result {
let token = opt_nonnull_to_ptr(token);
- (self.0.read_disk_ex)(&self.0, media_id, offset, token.cast(), len, buffer.cast())
- .to_result()
+ unsafe {
+ (self.0.read_disk_ex)(&self.0, media_id, offset, token.cast(), len, buffer.cast())
+ }
+ .to_result()
}
/// Writes bytes to the disk device.
@@ -164,14 +166,16 @@ impl DiskIo2 {
buffer: *const u8,
) -> Result {
let token = opt_nonnull_to_ptr(token);
- (self.0.write_disk_ex)(
- &mut self.0,
- media_id,
- offset,
- token.cast(),
- len,
- buffer.cast(),
- )
+ unsafe {
+ (self.0.write_disk_ex)(
+ &mut self.0,
+ media_id,
+ offset,
+ token.cast(),
+ len,
+ buffer.cast(),
+ )
+ }
.to_result()
}
diff --git a/uefi/src/proto/media/file/dir.rs b/uefi/src/proto/media/file/dir.rs
index e7623aa7a..79661c902 100644
--- a/uefi/src/proto/media/file/dir.rs
+++ b/uefi/src/proto/media/file/dir.rs
@@ -25,7 +25,7 @@ impl Directory {
/// doing otherwise is unsafe.
#[must_use]
pub const unsafe fn new(handle: FileHandle) -> Self {
- Self(RegularFile::new(handle))
+ Self(unsafe { RegularFile::new(handle) })
}
/// Read the next directory entry.
diff --git a/uefi/src/proto/media/file/info.rs b/uefi/src/proto/media/file/info.rs
index d8c2c6d6a..8a51b7ea5 100644
--- a/uefi/src/proto/media/file/info.rs
+++ b/uefi/src/proto/media/file/info.rs
@@ -45,7 +45,7 @@ trait InfoInternal: Align + ptr_meta::Pointee<Metadata = usize> {
/// struct.
unsafe fn name_ptr(ptr: *mut u8) -> *mut Char16 {
let offset_of_str = Self::name_offset();
- ptr.add(offset_of_str).cast::<Char16>()
+ unsafe { ptr.add(offset_of_str).cast::<Char16>() }
}
/// Create a new info type in user-provided storage.
@@ -95,13 +95,13 @@ trait InfoInternal: Align + ptr_meta::Pointee<Metadata = usize> {
// Create a pointer to the part of info where the name is
// stored. Note that `info_ptr` is used rather than `storage` to
// comply with Stacked Borrows.
- let info_name_ptr = Self::name_ptr(info_ptr.cast::<u8>());
+ let info_name_ptr = unsafe { Self::name_ptr(info_ptr.cast::<u8>()) };
// Initialize the name slice.
- ptr::copy(name.as_ptr(), info_name_ptr, name_length_ucs2);
+ unsafe { ptr::copy(name.as_ptr(), info_name_ptr, name_length_ucs2) };
// The struct is now valid and safe to dereference.
- let info = &mut *info_ptr;
+ let info = unsafe { &mut *info_ptr };
Ok(info)
}
}
@@ -111,10 +111,10 @@ where
T: InfoInternal + ?Sized,
{
unsafe fn from_uefi<'ptr>(ptr: *mut c_void) -> &'ptr mut Self {
- let name_ptr = Self::name_ptr(ptr.cast::<u8>());
- let name = CStr16::from_ptr(name_ptr);
+ let name_ptr = unsafe { Self::name_ptr(ptr.cast::<u8>()) };
+ let name = unsafe { CStr16::from_ptr(name_ptr) };
let name_len = name.as_slice_with_nul().len();
- &mut *ptr_meta::from_raw_parts_mut(ptr.cast::<()>(), name_len)
+ unsafe { &mut *ptr_meta::from_raw_parts_mut(ptr.cast::<()>(), name_len) }
}
}
diff --git a/uefi/src/proto/media/file/mod.rs b/uefi/src/proto/media/file/mod.rs
index fdf657327..d138d70a3 100644
--- a/uefi/src/proto/media/file/mod.rs
+++ b/uefi/src/proto/media/file/mod.rs
@@ -407,14 +407,18 @@ mod tests {
)
.unwrap();
let required_size = size_of_val(info);
- if *buffer_size < required_size {
- *buffer_size = required_size;
+ if unsafe { *buffer_size } < required_size {
+ unsafe {
+ *buffer_size = required_size;
+ }
Status::BUFFER_TOO_SMALL
} else {
unsafe {
ptr::copy_nonoverlapping((info as *const FileInfo).cast(), buffer, required_size);
}
- *buffer_size = required_size;
+ unsafe {
+ *buffer_size = required_size;
+ }
Status::SUCCESS
}
}
diff --git a/uefi/src/proto/tcg/v1.rs b/uefi/src/proto/tcg/v1.rs
index db8f13f85..8ab30f939 100644
--- a/uefi/src/proto/tcg/v1.rs
+++ b/uefi/src/proto/tcg/v1.rs
@@ -95,7 +95,7 @@ impl PcrEvent {
pub(super) const unsafe fn from_ptr<'a>(ptr: *const u8) -> &'a Self {
// Get the `event_size` field.
let ptr_u32: *const u32 = ptr.cast();
- let event_size = ptr_u32.add(7).read_unaligned();
+ let event_size = unsafe { ptr_u32.add(7).read_unaligned() };
let event_size = usize_from_u32(event_size);
unsafe { &*ptr_meta::from_raw_parts(ptr.cast(), event_size) }
}
diff --git a/uefi/src/proto/tcg/v2.rs b/uefi/src/proto/tcg/v2.rs
index 306993891..d13573d6e 100644
--- a/uefi/src/proto/tcg/v2.rs
+++ b/uefi/src/proto/tcg/v2.rs
@@ -452,35 +452,35 @@ pub struct PcrEvent<'a> {
impl<'a> PcrEvent<'a> {
unsafe fn from_ptr(ptr: *const u8, header: EventLogHeader<'a>) -> Option<Self> {
let ptr_u32: *const u32 = ptr.cast();
- let pcr_index = PcrIndex(ptr_u32.read_unaligned());
- let event_type = EventType(ptr_u32.add(1).read_unaligned());
- let digests_count = ptr_u32.add(2).read_unaligned();
- let digests_ptr: *const u8 = ptr.add(12);
+ let pcr_index = PcrIndex(unsafe { ptr_u32.read_unaligned() });
+ let event_type = EventType(unsafe { ptr_u32.add(1).read_unaligned() });
+ let digests_count = unsafe { ptr_u32.add(2).read_unaligned() };
+ let digests_ptr: *const u8 = unsafe { ptr.add(12) };
// Get the byte size of the digests so that the digests iterator
// can be safe code.
let mut digests_byte_size = 0;
let mut elem_ptr = digests_ptr;
for _ in 0..digests_count {
- let algorithm_id = AlgorithmId(elem_ptr.cast::<u16>().read_unaligned());
+ let algorithm_id = AlgorithmId(unsafe { elem_ptr.cast::<u16>().read_unaligned() });
let alg_and_digest_size = size_of::<AlgorithmId>()
+ usize::from(header.algorithm_digest_sizes.get_size(algorithm_id)?);
digests_byte_size += alg_and_digest_size;
- elem_ptr = elem_ptr.add(alg_and_digest_size);
+ elem_ptr = unsafe { elem_ptr.add(alg_and_digest_size) };
}
- let digests = slice::from_raw_parts(digests_ptr, digests_byte_size);
- let event_size_ptr = digests_ptr.add(digests_byte_size);
- let event_size = usize_from_u32(event_size_ptr.cast::<u32>().read_unaligned());
- let event_data_ptr = event_size_ptr.add(4);
- let event_data = slice::from_raw_parts(event_data_ptr, event_size);
+ let digests = unsafe { slice::from_raw_parts(digests_ptr, digests_byte_size) };
+ let event_size_ptr = unsafe { digests_ptr.add(digests_byte_size) };
+ let event_size = usize_from_u32(unsafe { event_size_ptr.cast::<u32>().read_unaligned() });
+ let event_data_ptr = unsafe { event_size_ptr.add(4) };
+ let event_data = unsafe { slice::from_raw_parts(event_data_ptr, event_size) };
Some(Self {
pcr_index,
event_type,
digests,
event_data,
- next: event_data_ptr.add(event_size),
+ next: unsafe { event_data_ptr.add(event_size) },
algorithm_digest_sizes: header.algorithm_digest_sizes,
})
}
diff --git a/uefi/src/runtime.rs b/uefi/src/runtime.rs
index 2d2450265..52802cf6d 100644
--- a/uefi/src/runtime.rs
+++ b/uefi/src/runtime.rs
@@ -75,7 +75,7 @@ pub unsafe fn set_time(time: &Time) -> Result {
let rt = unsafe { rt.as_ref() };
let time: *const Time = time;
- (rt.set_time)(time.cast()).to_result()
+ unsafe { (rt.set_time)(time.cast()) }.to_result()
}
/// Checks if a variable exists.
@@ -549,10 +549,11 @@ pub unsafe fn set_virtual_address_map(
let entry_size = size_of::<MemoryDescriptor>();
let entry_version = MemoryDescriptor::VERSION;
let map_ptr = map.as_mut_ptr();
- (rt.set_virtual_address_map)(map_size, entry_size, entry_version, map_ptr).to_result()?;
+ unsafe { (rt.set_virtual_address_map)(map_size, entry_size, entry_version, map_ptr) }
+ .to_result()?;
// Update the global system table pointer.
- table::set_system_table(new_system_table_virtual_addr);
+ unsafe { table::set_system_table(new_system_table_virtual_addr) };
Ok(())
}
diff --git a/uefi/src/util.rs b/uefi/src/util.rs
index 8119383e3..4abe0cda1 100644
--- a/uefi/src/util.rs
+++ b/uefi/src/util.rs
@@ -5,8 +5,10 @@ use core::ptr::{self, NonNull};
/// Copy the bytes of `val` to `ptr`, then advance pointer to just after the
/// newly-copied bytes.
pub unsafe fn ptr_write_unaligned_and_add<T>(ptr: &mut *mut u8, val: T) {
- ptr.cast::<T>().write_unaligned(val);
- *ptr = ptr.add(size_of::<T>());
+ unsafe {
+ ptr.cast::<T>().write_unaligned(val);
+ *ptr = ptr.add(size_of::<T>());
+ }
}
/// Convert from a `u32` to a `usize`. Panic if the input does fit. On typical