关于使用unsafe实现Coordinate与bytes::Bytes互转的正确性问询

问题背景 #

已知bytes::Bytes是零拷贝类型，需要实现它与自定义Coordinate类型的互转，目标是避免数据拷贝，首次使用unsafe，希望验证代码正确性。

原始代码 #

#[derive(Hash, Eq, PartialEq, Debug, Clone, Copy)]
pub struct Coordinate {
    pub z: u32,
    pub x: u32,
    pub y: u32,
}

impl From<bytes::Bytes> for Coordinate {
    fn from(value: bytes::Bytes) -> Self {
        unsafe {
            let ptr = value.as_ptr() as *const Coordinate;
            ptr.read_unaligned()
        }
    }
}

impl From<Coordinate> for bytes::Bytes {
    fn from(value: Coordinate) -> Self {
        let ptr = &value as *const Coordinate as *const u8;
        let slice = unsafe { std::slice::from_raw_parts(ptr, std::mem::size_of::<Coordinate>()) };
        bytes::Bytes::from_static(slice)
    }
}

代码问题分析 #

1. From<Coordinate> for bytes::Bytes实现的严重错误 #

bytes::Bytes::from_static要求传入的切片必须具有静态生命周期（'static），即内存地址必须永久有效（比如全局静态变量的内存）。但代码中ptr指向的是函数参数value——一个栈上的局部变量，函数执行完毕后这块栈内存会被回收，后续使用返回的Bytes会触发未定义行为（比如访问已释放内存），这是致命问题。

如果要实现零拷贝，必须保证Coordinate的内存来源具有足够长的生命周期：

• 若Coordinate是静态变量，直接用from_static没问题；
• 若Coordinate在堆上（比如Box<Coordinate>），可以将堆内存所有权转移给Bytes；
• 对于栈上的Coordinate值，无法实现零拷贝，必须将数据拷贝到堆上才能让Bytes安全持有。

2. From<bytes::Bytes> for Coordinate实现的潜在问题 #

• 长度未校验：代码没有检查Bytes的长度是否等于Coordinate的内存大小（12字节），如果Bytes长度不足，read_unaligned会读取越界内存，触发未定义行为；
• 字节序隐患：直接读取内存得到的u32值依赖当前平台的字节序（小端/大端），如果Bytes中的数据是网络字节序（大端），会导致数值错误；
• 对齐问题：虽然read_unaligned允许不对齐内存读取，但如果能确保Bytes的内存是对齐的，使用ptr.read()会更高效（不过read_unaligned本身是安全的，只要内存有效）。

修正后的代码示例 #

方案1：处理堆上Coordinate的零拷贝转换 #

如果你的Coordinate原本就在堆上（用Box持有），可以直接转移所有权给Bytes，实现真正零拷贝：

#[derive(Hash, Eq, PartialEq, Debug, Clone, Copy)]
pub struct Coordinate {
    pub z: u32,
    pub x: u32,
    pub y: u32,
}

// 从Bytes转Coordinate，增加长度校验
impl From<bytes::Bytes> for Coordinate {
    fn from(value: bytes::Bytes) -> Self {
        // 校验长度，避免越界
        assert_eq!(value.len(), std::mem::size_of::<Coordinate>());
        
        unsafe {
            // 若确定字节序与平台一致，用read_unaligned读取
            value.as_ptr().cast::<Coordinate>().read_unaligned()
        }
    }
}

// 从Box<Coordinate>转Bytes，零拷贝
impl From<Box<Coordinate>> for bytes::Bytes {
    fn from(value: Box<Coordinate>) -> Self {
        let ptr = Box::into_raw(value);
        let len = std::mem::size_of::<Coordinate>();
        // 将堆内存所有权转移给Bytes，Bytes会负责后续释放
        unsafe { bytes::Bytes::from_raw_parts(ptr.cast(), len, len) }
    }
}

方案2：处理栈上Coordinate（需一次拷贝） #

如果必须从栈上Coordinate转Bytes，只能通过堆拷贝实现安全持有，无法零拷贝：

impl From<Coordinate> for bytes::Bytes {
    fn from(value: Coordinate) -> Self {
        // 将栈上值拷贝到堆上的Vec，再转Bytes
        let vec = vec![
            (value.z >> 24) as u8, (value.z >> 16) as u8, (value.z >> 8) as u8, value.z as u8,
            (value.x >> 24) as u8, (value.x >> 16) as u8, (value.x >> 8) as u8, value.x as u8,
            (value.y >> 24) as u8, (value.y >> 16) as u8, (value.y >> 8) as u8, value.y as u8,
        ];
        bytes::Bytes::from(vec)
    }
}

方案3：处理跨平台字节序（无unsafe更安全） #

如果Bytes中的数据是网络字节序，推荐使用byteorder库处理，避免unsafe：

use byteorder::{BigEndian, ReadBytesExt};

impl From<bytes::Bytes> for Coordinate {
    fn from(value: bytes::Bytes) -> Self {
        assert_eq!(value.len(), 12);
        let mut cursor = std::io::Cursor::new(value);
        Coordinate {
            z: cursor.read_u32::<BigEndian>().unwrap(),
            x: cursor.read_u32::<BigEndian>().unwrap(),
            y: cursor.read_u32::<BigEndian>().unwrap(),
        }
    }
}

内容的提问来源于stack exchange，提问作者bli00