add "unstable_alloc" feature and {get_boxed_info, read_entry_boxed_}in-methods

Author: phip1611

Diff for: CHANGELOG.md

@@ -1,21 +1,40 @@
 # Changelog
 
 ## uefi - [Unreleased]
+
+### Added
 - Implementations for the trait `EqStrUntilNul` now allow `?Sized` inputs. This means that
   you can write `some_cstr16.eq_str_until_nul("test")` instead of
   `some_cstr16.eq_str_until_nul(&"test")` now.
 - Added `TryFrom<core::ffi::CStr>` implementation for `CStr8`.
 - Added `Directory::read_entry_boxed` which works similar to `File::get_boxed_info`. This allows
-  easier iteration over the entries in a directory.
-- Added an `core::error::Error` implementation for `Error` to ease
-  integration with error-handling crates. (requires the **unstable** feature)
+  easier iteration over the entries in a directory. (requires the **unstable_alloc** feature)
 - Added `Directory::read_entry_boxed_in` and `File::get_boxed_info_in` that use the `allocator_api`
-  feature. (requires the **unstable** feature)
+  feature. (requires the **unstable_alloc** feature)
+- Added an `core::error::Error` implementation for `Error` to ease
+    integration with error-handling crates. (requires the **unstable** feature)
+
+### Changed
+- `File::get_boxed_info` requires the **unstable** feature
+
+### Removed
 
 ## uefi-macros - [Unreleased]
 
+### Added
+
+### Changed
+
+### Removed
+
 ## uefi-services - [Unreleased]
 
+### Added
+
+### Changed
+
+### Removed
+
 ## uefi - 0.18.0 (2022-11-15)
 
 ### Added

Diff for: uefi-test-runner/Cargo.toml

@@ -6,7 +6,7 @@ publish = false
 edition = "2021"
 
 [dependencies]
-uefi = { path = "../uefi", features = ['alloc'] }
+uefi = { path = "../uefi", features = ["alloc", "unstable_alloc"] }
 uefi-services = { path = "../uefi-services" }
 
 log = { version = "0.4.17", default-features = false }

Diff for: uefi/Cargo.toml

@@ -19,7 +19,11 @@ logger = []
 # were observed on the VirtualBox UEFI implementation (see uefi-rs#121).
 # In those cases, this feature can be excluded by removing the default features.
 panic-on-logger-errors = []
+# Enables all generic functionality that requires unstable Rust language features. To use
+# features behind this feature gate, you usually need a nightly toolchain.
 unstable = []
+# Like the `unstable` feature but specific to `alloc`-related functionality.
+unstable_alloc = ["unstable", "alloc"]
 
 [dependencies]
 bitflags = "1.3.1"

Diff for: uefi/src/lib.rs

@@ -62,8 +62,7 @@
 #![feature(ptr_metadata)]
 #![cfg_attr(feature = "alloc", feature(vec_into_raw_parts))]
 #![cfg_attr(feature = "unstable", feature(error_in_core))]
-#![cfg_attr(feature = "unstable", feature(allocator_api))]
-#![cfg_attr(feature = "unstable", feature(slice_ptr_get))]
+#![cfg_attr(feature = "unstable_alloc", feature(allocator_api))]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![no_std]
 // Enable some additional warnings and lints.

Diff for: uefi/src/mem.rs

@@ -1,16 +1,22 @@
 //! This is a utility module with helper methods for allocations/memory.
 
-use crate::ResultExt;
-use crate::{Result, Status};
-use ::alloc::{alloc::Global, boxed::Box};
-use core::alloc::{Allocator, Layout};
-use core::fmt::Debug;
-use core::ptr::NonNull;
-use uefi::data_types::Align;
-use uefi::Error;
+#[cfg(feature = "unstable_alloc")]
+use {
+    crate::ResultExt,
+    crate::{Result, Status},
+    ::alloc::boxed::Box,
+    alloc::alloc::Global,
+    core::alloc::Allocator,
+    core::alloc::Layout,
+    core::fmt::Debug,
+    core::ptr::NonNull,
+    uefi::data_types::Align,
+    uefi::Error,
+};
 
 /// Wrapper around [`make_boxed_in`] that uses [`Global`]/the system allocator.
 #[allow(unused)]
+#[cfg(feature = "unstable_alloc")]
 pub fn make_boxed<
     'a,
     Data: Align + ?Sized + Debug + 'a,
@@ -31,6 +37,7 @@ pub fn make_boxed<
 ///   success.
 ///
 /// It takes a custom allocator via the `allocator_api`.
+#[cfg(feature = "unstable_alloc")]
 pub fn make_boxed_in<
     'a,
     A: Allocator,
@@ -71,7 +78,12 @@ pub fn make_boxed_in<
     let data: &mut Data = match data {
         Ok(data) => data,
         Err(err) => {
-            unsafe { allocator.deallocate(heap_buf.as_non_null_ptr(), layout) };
+            // The deallocate function only takes the begin pointer but not a pointer to the
+            // whole slice. To prevent unsafe slice features, we do the conversion here manually
+            // - at the costs of some clutter code.
+            let ptr = unsafe { &mut *heap_buf.as_ptr().cast::<u8>() };
+            let ptr = NonNull::new(ptr).unwrap();
+            unsafe { allocator.deallocate(ptr, layout) };
             return Err(err);
         }
     };

Diff for: uefi/src/proto/media/file/dir.rs

@@ -3,7 +3,7 @@ use crate::data_types::Align;
 use crate::Result;
 use core::ffi::c_void;
 
-#[cfg(feature = "alloc")]
+#[cfg(feature = "unstable_alloc")]
 use {crate::mem::make_boxed_in, alloc::alloc::Global, alloc::boxed::Box, core::alloc::Allocator};
 
 /// A `FileHandle` that is also a directory.
@@ -62,7 +62,7 @@ impl Directory {
     }
 
     /// Wrapper around [`Self::read_entry_boxed_in`] that uses the [`Global`] allocator.
-    #[cfg(feature = "alloc")]
+    #[cfg(feature = "unstable_alloc")]
     pub fn read_entry_boxed(&mut self) -> Result<Option<Box<FileInfo>>> {
         self.read_entry_boxed_in(Global)
     }
@@ -71,7 +71,7 @@ impl Directory {
     /// implications and requirements. On failure, the payload of `Err` is `()´.
     ///
     /// It allows to use a custom allocator via the `allocator_api` feature.
-    #[cfg(feature = "alloc")]
+    #[cfg(feature = "unstable_alloc")]
     pub fn read_entry_boxed_in<A: Allocator>(
         &mut self,
         allocator: A,

Diff for: uefi/src/proto/media/file/mod.rs

@@ -16,7 +16,7 @@ use core::ffi::c_void;
 use core::fmt::Debug;
 use core::mem;
 use core::ptr;
-#[cfg(feature = "alloc")]
+#[cfg(feature = "unstable_alloc")]
 use {alloc::alloc::Global, alloc::boxed::Box, core::alloc::Allocator, uefi::mem::make_boxed_in};
 
 pub use self::info::{FileInfo, FileProtocolInfo, FileSystemInfo, FileSystemVolumeLabel, FromUefi};
@@ -161,14 +161,14 @@ pub trait File: Sized {
         (self.imp().flush)(self.imp()).into()
     }
 
-    #[cfg(feature = "alloc")]
     /// Wrapper around [`Self::get_boxed_info_in`] that uses the [`Global`] allocator.
+    #[cfg(feature = "unstable_alloc")]
     fn get_boxed_info<Info: FileProtocolInfo + ?Sized + Debug>(&mut self) -> Result<Box<Info>> {
         self.get_boxed_info_in(Global)
     }
 
-    #[cfg(feature = "alloc")]
     /// Read the dynamically allocated info for a file.
+    #[cfg(feature = "unstable_alloc")]
     fn get_boxed_info_in<Info: FileProtocolInfo + ?Sized + Debug, A: Allocator>(
         &mut self,
         allocator: A,