Compiler Explorer

Source code

use core::mem::MaybeUninit;
use core::sync::atomic::{Ordering, AtomicBool};
use core::cell::UnsafeCell;

type Config = (); // exposition only

#[repr(C)]
struct SharedData {
    secondary_boot_flag: AtomicBool,
    primary_init_flag: AtomicBool,
    config: UnsafeCell<Option<Config>>,
}

impl SharedData {

pub const fn new() -> Self {
        Self {
            secondary_boot_flag: AtomicBool::new(false),
            primary_init_flag: AtomicBool::new(false),
            config: UnsafeCell::new(None),
        }
    }

pub fn primary_set_config(&mut self, config: Config) -> &Config {
        while ! self.secondary_boot_flag.load(Ordering::Acquire) {
            // spin
        }
        let x = unsafe {&mut *self.config.get()}.insert(config);
        self.primary_init_flag.store(true, Ordering::Release);
        x
    }

pub fn secondary_get_config(&self) -> &Config {
        while ! self.primary_init_flag.load(Ordering::Acquire)  {
            self.secondary_boot_flag.store(true, Ordering::Release);
        }
        unsafe {&*self.config.get()}.as_ref().unwrap()
    }

}

struct SharedDataCell(UnsafeCell<MaybeUninit<SharedData>>);

unsafe impl Send for SharedDataCell {}
unsafe impl Sync for SharedDataCell {}

impl SharedDataCell {
    pub const fn uninit() -> Self {
        Self(UnsafeCell::new(MaybeUninit::uninit()))
    }
    /// Safety: should only be called once
    pub unsafe fn init(&self) -> &mut SharedData {
        (&mut *self.0.get()).write(SharedData::new())
    }
}

/// Safety: Should only be called once.
unsafe fn shared_data() -> &'static mut SharedData {
    static CELL: SharedDataCell = SharedDataCell::uninit();
    CELL.init() 
}

pub fn main_primary() -> &'static Config {
    let data = unsafe { shared_data() };
    let config = (); // exposition only
    data.primary_set_config(config)
}

pub fn main_secondary() -> &'static Config {
    let data = unsafe { shared_data() };
    data.secondary_get_config()
}