Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Simplify VFS initialization #569

Merged
merged 2 commits into from
Dec 16, 2024
Merged

Simplify VFS initialization #569

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
8432401
Simplify VFS initialization
sosthene-nitrokey Dec 9, 2024
e8c0603
Use MaybeUninit for all stores
sosthene-nitrokey Dec 10, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
93 changes: 52 additions & 41 deletions components/boards/src/store.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,6 +1,7 @@
use core::{
marker::PhantomData,
mem::MaybeUninit,
ptr::addr_of_mut,
sync::atomic::{AtomicBool, Ordering},
};

Expand Down Expand Up @@ -37,7 +38,7 @@ const_ram_storage!(
#[allow(clippy::missing_safety_doc)]
#[cfg(feature = "provisioner")]
pub unsafe fn steal_internal_storage<S: StoragePointers>() -> &'static mut S::InternalStorage {
S::ifs_storage().as_mut().unwrap()
S::ifs_storage().assume_init_mut()
}

// FIXME: document safety
Expand All @@ -46,14 +47,14 @@ pub trait StoragePointers: 'static {
type InternalStorage: Storage;
type ExternalStorage: Storage;

unsafe fn ifs_storage() -> &'static mut Option<Self::InternalStorage>;
unsafe fn ifs_alloc() -> &'static mut Option<Allocation<Self::InternalStorage>>;
unsafe fn ifs() -> &'static mut Option<Filesystem<'static, Self::InternalStorage>>;
unsafe fn ifs_storage() -> &'static mut MaybeUninit<Self::InternalStorage>;
unsafe fn ifs_alloc() -> &'static mut MaybeUninit<Allocation<Self::InternalStorage>>;
unsafe fn ifs() -> &'static mut MaybeUninit<Filesystem<'static, Self::InternalStorage>>;
unsafe fn ifs_ptr() -> *mut Fs<Self::InternalStorage>;

unsafe fn efs_storage() -> &'static mut Option<Self::ExternalStorage>;
unsafe fn efs_alloc() -> &'static mut Option<Allocation<Self::ExternalStorage>>;
unsafe fn efs() -> &'static mut Option<Filesystem<'static, Self::ExternalStorage>>;
unsafe fn efs_storage() -> &'static mut MaybeUninit<Self::ExternalStorage>;
unsafe fn efs_alloc() -> &'static mut MaybeUninit<Allocation<Self::ExternalStorage>>;
unsafe fn efs() -> &'static mut MaybeUninit<Filesystem<'static, Self::ExternalStorage>>;
unsafe fn efs_ptr() -> *mut Fs<Self::ExternalStorage>;
}

Expand All @@ -67,57 +68,67 @@ macro_rules! impl_storage_pointers {
type InternalStorage = $I;
type ExternalStorage = $E;

unsafe fn ifs_storage() -> &'static mut Option<Self::InternalStorage> {
static mut IFS_STORAGE: Option<$I> = None;
unsafe fn ifs_storage() -> &'static mut ::core::mem::MaybeUninit<Self::InternalStorage>
{
static mut IFS_STORAGE: ::core::mem::MaybeUninit<$I> =
::core::mem::MaybeUninit::uninit();
#[allow(static_mut_refs)]
&mut IFS_STORAGE
}

unsafe fn ifs_alloc(
) -> &'static mut Option<::littlefs2::fs::Allocation<Self::InternalStorage>> {
static mut IFS_ALLOC: Option<::littlefs2::fs::Allocation<$I>> = None;
unsafe fn ifs_alloc() -> &'static mut ::core::mem::MaybeUninit<
::littlefs2::fs::Allocation<Self::InternalStorage>,
> {
static mut IFS_ALLOC: ::core::mem::MaybeUninit<::littlefs2::fs::Allocation<$I>> =
::core::mem::MaybeUninit::uninit();
#[allow(static_mut_refs)]
&mut IFS_ALLOC
}

unsafe fn ifs(
) -> &'static mut Option<::littlefs2::fs::Filesystem<'static, Self::InternalStorage>>
{
static mut IFS: Option<::littlefs2::fs::Filesystem<$I>> = None;
unsafe fn ifs() -> &'static mut ::core::mem::MaybeUninit<
::littlefs2::fs::Filesystem<'static, Self::InternalStorage>,
> {
static mut IFS: ::core::mem::MaybeUninit<::littlefs2::fs::Filesystem<$I>> =
::core::mem::MaybeUninit::uninit();
#[allow(static_mut_refs)]
&mut IFS
}

unsafe fn ifs_ptr() -> *mut ::trussed::store::Fs<Self::InternalStorage> {
use ::core::mem::MaybeUninit;
static mut IFS: MaybeUninit<::trussed::store::Fs<$I>> = MaybeUninit::uninit();
static mut IFS: ::core::mem::MaybeUninit<::trussed::store::Fs<$I>> =
::core::mem::MaybeUninit::uninit();
IFS.as_mut_ptr()
}

unsafe fn efs_storage() -> &'static mut Option<Self::ExternalStorage> {
static mut EFS_STORAGE: Option<$E> = None;
unsafe fn efs_storage() -> &'static mut ::core::mem::MaybeUninit<Self::ExternalStorage>
{
static mut EFS_STORAGE: ::core::mem::MaybeUninit<$E> =
::core::mem::MaybeUninit::uninit();
#[allow(static_mut_refs)]
&mut EFS_STORAGE
}

unsafe fn efs_alloc(
) -> &'static mut Option<::littlefs2::fs::Allocation<Self::ExternalStorage>> {
static mut EFS_ALLOC: Option<::littlefs2::fs::Allocation<$E>> = None;
unsafe fn efs_alloc() -> &'static mut ::core::mem::MaybeUninit<
::littlefs2::fs::Allocation<Self::ExternalStorage>,
> {
static mut EFS_ALLOC: ::core::mem::MaybeUninit<::littlefs2::fs::Allocation<$E>> =
::core::mem::MaybeUninit::uninit();
#[allow(static_mut_refs)]
&mut EFS_ALLOC
}

unsafe fn efs(
) -> &'static mut Option<::littlefs2::fs::Filesystem<'static, Self::ExternalStorage>>
{
static mut EFS: Option<::littlefs2::fs::Filesystem<$E>> = None;
unsafe fn efs() -> &'static mut ::core::mem::MaybeUninit<
::littlefs2::fs::Filesystem<'static, Self::ExternalStorage>,
> {
static mut EFS: ::core::mem::MaybeUninit<::littlefs2::fs::Filesystem<$E>> =
::core::mem::MaybeUninit::uninit();
#[allow(static_mut_refs)]
&mut EFS
}

unsafe fn efs_ptr() -> *mut ::trussed::store::Fs<Self::ExternalStorage> {
use ::core::mem::MaybeUninit;
static mut EFS: MaybeUninit<::trussed::store::Fs<$E>> = MaybeUninit::uninit();
static mut EFS: ::core::mem::MaybeUninit<::trussed::store::Fs<$E>> =
::core::mem::MaybeUninit::uninit();
EFS.as_mut_ptr()
}
}
Expand Down Expand Up @@ -194,36 +205,36 @@ pub fn init_store<B: Board>(
.compare_exchange_weak(false, true, Ordering::AcqRel, Ordering::Acquire)
.expect("multiple instances of RunnerStore are not allowed");

static mut VOLATILE_STORAGE: Option<VolatileStorage> = None;
static mut VOLATILE_FS_ALLOC: Option<Allocation<VolatileStorage>> = None;
static mut VOLATILE_FS: Option<Filesystem<VolatileStorage>> = None;
static mut VOLATILE_STORAGE: MaybeUninit<VolatileStorage> = MaybeUninit::uninit();
static mut VOLATILE_FS_ALLOC: MaybeUninit<Allocation<VolatileStorage>> = MaybeUninit::uninit();
static mut VOLATILE_FS: MaybeUninit<Filesystem<VolatileStorage>> = MaybeUninit::uninit();

unsafe {
let ifs_storage = B::ifs_storage().insert(int_flash);
let ifs_alloc = B::ifs_alloc().insert(Filesystem::allocate());
let efs_storage = B::efs_storage().insert(ext_flash);
let efs_alloc = B::efs_alloc().insert(Filesystem::allocate());
let vfs_storage = VOLATILE_STORAGE.insert(VolatileStorage::new());
let vfs_alloc = VOLATILE_FS_ALLOC.insert(Filesystem::allocate());
let ifs_storage = B::ifs_storage().write(int_flash);
let ifs_alloc = B::ifs_alloc().write(Filesystem::allocate());
let efs_storage = B::efs_storage().write(ext_flash);
let efs_alloc = B::efs_alloc().write(Filesystem::allocate());
let vfs_storage = (*addr_of_mut!(VOLATILE_STORAGE)).write(VolatileStorage::new());
let vfs_alloc = (*addr_of_mut!(VOLATILE_FS_ALLOC)).write(Filesystem::allocate());

let ifs = match init_ifs::<B>(ifs_storage, ifs_alloc, efs_storage, status) {
Ok(ifs) => B::ifs().insert(ifs),
Ok(ifs) => B::ifs().write(ifs),
Err(_e) => {
error!("IFS Mount Error {:?}", _e);
panic!("IFS");
}
};

let efs = match init_efs::<B>(efs_storage, efs_alloc, simulated_efs, status) {
Ok(efs) => B::efs().insert(efs),
Ok(efs) => B::efs().write(efs),
Err(_e) => {
error!("EFS Mount Error {:?}", _e);
panic!("EFS");
}
};

let vfs = match init_vfs(vfs_storage, vfs_alloc) {
Ok(vfs) => VOLATILE_FS.insert(vfs),
Ok(vfs) => (*addr_of_mut!(VOLATILE_FS)).write(vfs),
Err(_e) => {
error!("VFS Mount Error {:?}", _e);
panic!("VFS");
Expand Down
2 changes: 1 addition & 1 deletion utils/nrf-debugging/walk.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,7 +26,7 @@
read_size = args.read_size
prog_size = args.prog_size

block_count = img_size / block_size
block_count = img_size // block_size
if block_count * block_size != img_size:
print("image size should be a multiple of block size")
exit(1)
Expand Down