Is there some crate out there that provides something like a raw buffer slice:

```rust
#[derive(Debug, Copy, Clone)]
struct RawBufSlice {
    data: *const u8,
    len: usize,
}

/// Safety: This type MUST be used with mutex to ensure concurrent access is valid.
unsafe impl Send for RawBufSlice {}

impl RawBufSlice {
    /// # Safety
    ///
    /// This function stores the raw pointer of the passed data slice. The user MUST ensure
    /// that the slice outlives the data structure.
    #[allow(dead_code)]
    const unsafe fn new(data: &[u8]) -> Self {
        Self {
            data: data.as_ptr(),
            len: data.len(),
        }
    }

    const fn new_empty() -> Self {
        Self {
            data: core::ptr::null(),
            len: 0,
        }
    }

    /// # Safety
    ///
    /// This function stores the raw pointer of the passed data slice. The user MUST ensure
    /// that the slice outlives the data structure.
    pub unsafe fn set(&mut self, data: &[u8]) {
        self.data = data.as_ptr();
        self.len = data.len();
    }
}
```

I basically a shared instance of this to pass data to an async TX driver.