最近在学习写riscv的no_std rust。但是，在实现堆分配器时，采用了MaybeUninit去初始化链表。但是，在运行时创建堆分配器对象，就会报错"ptr::write_bytes requires that the destination pointer is aligned and non-null"。

debug下来发现是 MaybeUninit::zeroed中调用的MaybeUninit::<T>::uninit()创建的变量的地址，不满足类型的8字节对齐要求，后面就一直报错。

在删除代码去定位原因时，发现：

1. 不使用OnceCell，不报错。

2. OnceCell里面不是BuddyAllocator不报错。

3. 不调用OnceCell::get_or_init()不报错。

我不理解为何使用MaybeUnint创建的变量地址会没有对齐。这个是我做错了什么，导致触发UB吗？有知道的大佬可以告诉一下吗？感激不尽。

程序是跑在 archlinux中的qemu 9.1.1的riscv虚拟机中，运行命令是：

cargo build && qemu-system-riscv64 -machine virt -nographic -bios none  -m 1024M -kernel ./target/riscv64imac-unknown-none-elf/debug/demo -S -s

下面是简化后的，可以触发报错的代码。会报错的一行是init_heap中的_test变量处。

//! target 是：riscv64imac-unknown-none-elf
//!
//! 该程序的连接脚本是：
//! MEMORY {
//! DRAM : ORIGIN = 0x80000000, LENGTH = 320M
//! }
//!
//! ENTRY(_start)
//!
//! SECTIONS {
//!     . = 0x80000000;
//!
//!     .text : {
//!         *(.text.entry)
//!         *(.text)
//!     } > DRAM
//!
//!     .rodata : {
//!         *(.rodata)
//!     } > DRAM
//!
//!     .data : {
//!         *(.data)
//!     } > DRAM
//!
//!     .bss : {
//!         *(.bss)
//!     } > DRAM
//!
//!     . = ALIGN(16);
//!     _kernel_end = .;
//! }
//!
#![no_std]
#![no_main]

use core::arch::global_asm;
use core::cell::OnceCell;

global_asm!(
    r#"
    .align   2
    .section .text.entry
    .global  _start
_start:
    la       sp, __stack_top
    call     start
    j        .

    .align   4
    .section .bss
    .global  __stack_bottom
__stack_bottom:
    .space   409600
__stack_top:
"#
);

#[macro_export]
macro_rules! entry {
    ($f:ident) => {
        #[no_mangle]
        extern "C" fn start() -> ! {
            let f: fn() -> ! = $f;
            f()
        }
    };
}

use mm::spin_sync::SpinLock;
use mm::BuddyAllocator;

#[global_allocator]
pub static STATIC_HEAP: SpinLock<OnceCell<BuddyAllocator<20>>> = SpinLock::new(OnceCell::new());
pub fn init_heap() {
    use core::mem::MaybeUninit;
    use mm::phy_list;

    let _test: MaybeUninit<phy_list::PhyList> = MaybeUninit::zeroed();
    // 上面的zeroed就会panic了

    STATIC_HEAP.lock().get_or_init(|| todo!());
}

entry!(main);

fn main() -> ! {
    init_heap();
    loop {}
}

#[panic_handler]
fn panic(_info: &core::panic::PanicInfo) -> ! {
    loop {}
}

mod mm {
    use core::{
        alloc::{GlobalAlloc, Layout},
        cell::OnceCell,
        mem::{self},
        ptr::NonNull,
    };
    use spin_sync::SpinLock;

    pub mod phy_list {
        #![allow(unused)]
        //! 会利用指向空间记录下一个节点的地址，从而实现链表的功能
        //! 该链表用于管理预分配的静态内存的分配和释放
        //! 不能进行通用链表操作。

        use core::ptr::{self, NonNull};
        #[repr(transparent)]
        #[derive(Debug, Clone, Copy)]
        pub struct PhyList {
            head: Option<NonNull<usize>>,
        }
    }

    pub mod spin_sync {
        use core::cell::UnsafeCell;

        pub struct SpinLock<T> {
            lock: core::sync::atomic::AtomicBool,
            data: UnsafeCell<T>,
        }
        pub struct SpinGuard<'a, T> {
            inner: &'a SpinLock<T>,
        }
        unsafe impl<T> Sync for SpinLock<T> {}
        impl<T> SpinLock<T> {
            pub const fn new(data: T) -> Self {
                Self {
                    lock: core::sync::atomic::AtomicBool::new(false),
                    data: UnsafeCell::new(data),
                }
            }
            pub fn lock(&self) -> SpinGuard<T> {
                while self.lock.swap(true, core::sync::atomic::Ordering::Acquire) {
                    // spin
                }
                SpinGuard { inner: self }
            }
        }
        impl<'a, T> Drop for SpinGuard<'a, T> {
            fn drop(&mut self) {
                self.inner
                    .lock
                    .store(false, core::sync::atomic::Ordering::Release);
            }
        }
        impl<'a, T> core::ops::Deref for SpinGuard<'a, T> {
            type Target = T;
            fn deref(&self) -> &Self::Target {
                // SAFETY: SpinGuard is only created when SpinLock is locked.
                unsafe { &*self.inner.data.get() }
            }
        }
        impl<'a, T> core::ops::DerefMut for SpinGuard<'a, T> {
            fn deref_mut(&mut self) -> &mut Self::Target {
                // SAFETY: SpinGuard is only created when SpinLock is locked.
                unsafe { &mut *self.inner.data.get() }
            }
        }
    }

    /// 伙伴分配器
    /// N: 空闲链表的数量，
    /// BALIGN: 对齐的位数，即2^BALIGN，要求不小于usize的字节数，一般是2^3=8，此时BALIGN=3。
    /// N+BALIGN 必须小于usize的位数（一般是64），否则会溢出。
    /// FIXME: 由于rust目前没法限制const泛型的范围，所以这里只能在使用的时候保证N和ALIGN的范围。
    pub struct BuddyAllocator<
        const N: usize,
        const BALIGN: u8 = { mem::size_of::<usize>().trailing_zeros() as u8 },
    > {
        free_list: [phy_list::PhyList; N],
        total_size: usize,
        allocated_size: usize,
    }

    impl<const N: usize, const BALIGN: u8> BuddyAllocator<N, BALIGN> {
        pub fn allocate(&mut self, layout: Layout) -> Option<NonNull<u8>> {
            todo!()
        }

        pub fn deallocate(&mut self, ptr: NonNull<u8>, layout: Layout) {
            todo!()
        }
    }

    unsafe impl GlobalAlloc for SpinLock<OnceCell<BuddyAllocator<20, 3>>> {
        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
            self.lock()
                .get_mut()
                .map(|allocator| allocator.allocate(layout))
                .flatten()
                .map_or(core::ptr::null_mut(), |ptr| ptr.as_ptr())
        }

        unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
            let ptr = NonNull::new(ptr);
            if let Some(ptr) = ptr {
                self.lock()
                    .get_mut()
                    .map(|allocator| allocator.deallocate(ptr, layout));
            }
        }
    }
}