libcras: Implement UnalignedRef for unaligned memory access

Add UnaglinedRef struct, which is similar to the VolatileRef struct but
it uses {read, write}_unaligned instead.

BUG=b:239850356
BUG=b:284938484
TEST=cargo test

Change-Id: Icc0479b14ff751f146b6096c16f3bb2f62031700
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/third_party/adhd/+/4574167
Tested-by: Chih-Yang Hsia <[email protected]>
Reviewed-by: Li-Yu Yu <[email protected]>
Commit-Queue: Chih-Yang Hsia <[email protected]>
Tested-by: ChromeOS Audio Quick Verifier <[email protected]>
Tested-by: [email protected] <[email protected]>

Author: b92paul

cras/client/libcras/src/cras_shm.rs

@@ -20,9 +20,11 @@ use cras_sys::gen::{
 use cras_sys::{
     AudioDebugInfo, AudioDevDebugInfo, AudioStreamDebugInfo, CrasIodevInfo, CrasIonodeInfo,
 };
-use data_model::{VolatileRef, VolatileSlice};
+use data_model::VolatileSlice;
 use libchromeos::sys::warn;
 
+use crate::unaligned_memory::UnalignedRef;
+
 /// A structure wrapping a fd which contains a shared `cras_audio_shm_header`.
 /// * `shm_fd` - A shared memory fd contains a `cras_audio_shm_header`
 pub struct CrasAudioShmHeaderFd {
@@ -52,46 +54,46 @@ impl CrasAudioShmHeaderFd {
 
 /// A wrapper for the raw structure `cras_audio_shm_header` with
 /// size information for the separate audio samples shm area and several
-/// `VolatileRef` to sub fields for safe access to the header.
+/// `UnalignedRef` to sub fields for safe access to the header.
 pub struct CrasAudioHeader<'a> {
     addr: *mut libc::c_void,
     /// Size of the buffer for samples in CrasAudioBuffer
     samples_len: usize,
-    used_size: VolatileRef<'a, u32>,
-    frame_size: VolatileRef<'a, u32>,
-    read_buf_idx: VolatileRef<'a, u32>,
-    write_buf_idx: VolatileRef<'a, u32>,
-    read_offset: [VolatileRef<'a, u32>; CRAS_NUM_SHM_BUFFERS as usize],
-    write_offset: [VolatileRef<'a, u32>; CRAS_NUM_SHM_BUFFERS as usize],
-    buffer_offset: [VolatileRef<'a, u64>; CRAS_NUM_SHM_BUFFERS as usize],
-    ts_sec: VolatileRef<'a, i64>,
-    ts_nsec: VolatileRef<'a, i64>,
+    used_size: UnalignedRef<'a, u32>,
+    frame_size: UnalignedRef<'a, u32>,
+    read_buf_idx: UnalignedRef<'a, u32>,
+    write_buf_idx: UnalignedRef<'a, u32>,
+    read_offset: [UnalignedRef<'a, u32>; CRAS_NUM_SHM_BUFFERS as usize],
+    write_offset: [UnalignedRef<'a, u32>; CRAS_NUM_SHM_BUFFERS as usize],
+    buffer_offset: [UnalignedRef<'a, u64>; CRAS_NUM_SHM_BUFFERS as usize],
+    ts_sec: UnalignedRef<'a, i64>,
+    ts_nsec: UnalignedRef<'a, i64>,
 }
 
 // It is safe to send audio buffers between threads as this struct has exclusive ownership of the
 // pointers contained in it.
 unsafe impl<'a> Send for CrasAudioHeader<'a> {}
 
-/// An unsafe macro for getting `VolatileRef` for a field from a given NonNull pointer.
+/// An unsafe macro for getting `UnalignedRef` for a field from a given NonNull pointer.
 /// It Supports
 /// - Nested sub-field
 /// - Element of an array field
 ///
 /// To use this macro safely, we need to
 /// - Make sure the pointer address is readable and writable for its structure.
-/// - Make sure all `VolatileRef`s generated from this macro have exclusive ownership for the same
+/// - Make sure all `UnalignedRef`s generated from this macro have exclusive ownership for the same
 /// pointer.
 ///
-/// TODO(b/239850356): Use self-implemented `VolatileRef` implemetation
+/// TODO(b/239850356): Use self-implemented `UnalignedRef` implemetation
 /// with [`ptr::read_unaligned`] and [`ptr::write_unaligned`].
 #[macro_export]
 macro_rules! vref_from_addr {
     ($addr:ident, $($field:ident).*) => {
-        VolatileRef::new(ptr::addr_of_mut!($addr.as_mut().$($field).*))
+        UnalignedRef::new(ptr::addr_of_mut!($addr.as_mut().$($field).*))
     };
 
     ($addr:ident, $field:ident[$idx:tt]) => {
-        VolatileRef::new(ptr::addr_of_mut!($addr.as_mut().$field[$idx]))
+        UnalignedRef::new(ptr::addr_of_mut!($addr.as_mut().$field[$idx]))
     };
 }
 
@@ -553,20 +555,20 @@ macro_rules! vslice_from_addr {
 #[derive(Debug)]
 pub struct CrasServerState<'a> {
     addr: *mut libc::c_void,
-    volume: VolatileRef<'a, u32>,
-    mute: VolatileRef<'a, i32>,
-    num_output_devs: VolatileRef<'a, u32>,
+    volume: UnalignedRef<'a, u32>,
+    mute: UnalignedRef<'a, i32>,
+    num_output_devs: UnalignedRef<'a, u32>,
     output_devs: VolatileSlice<'a>,
-    num_input_devs: VolatileRef<'a, u32>,
+    num_input_devs: UnalignedRef<'a, u32>,
     input_devs: VolatileSlice<'a>,
-    num_output_nodes: VolatileRef<'a, u32>,
-    num_input_nodes: VolatileRef<'a, u32>,
+    num_output_nodes: UnalignedRef<'a, u32>,
+    num_input_nodes: UnalignedRef<'a, u32>,
     output_nodes: VolatileSlice<'a>,
     input_nodes: VolatileSlice<'a>,
-    update_count: VolatileRef<'a, u32>,
-    debug_info_num_devs: VolatileRef<'a, u32>,
+    update_count: UnalignedRef<'a, u32>,
+    debug_info_num_devs: UnalignedRef<'a, u32>,
     debug_info_devs: VolatileSlice<'a>,
-    debug_info_num_streams: VolatileRef<'a, u32>,
+    debug_info_num_streams: UnalignedRef<'a, u32>,
     debug_info_streams: VolatileSlice<'a>,
 }
 

cras/client/libcras/src/libcras.rs

@@ -161,6 +161,7 @@ mod cras_stream;
 use crate::cras_stream::{CrasCaptureData, CrasPlaybackData, CrasStream, CrasStreamData};
 mod cras_client_message;
 use crate::cras_client_message::*;
+mod unaligned_memory;
 
 #[derive(Debug)]
 pub enum Error {

cras/client/libcras/src/unaligned_memory.rs

@@ -0,0 +1,73 @@
+// Copyright 2023 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use std::marker::PhantomData;
+
+use data_model::DataInit;
+
+/// A memory location that supports unaligned access of a `T`.
+#[derive(Debug)]
+pub struct UnalignedRef<'a, T: DataInit>
+where
+    T: 'a,
+{
+    addr: *mut T,
+    phantom: PhantomData<&'a T>,
+}
+
+impl<'a, T: DataInit> UnalignedRef<'a, T> {
+    /// Creates a reference to raw unaligned memory that must support unaligned access of `T`
+    /// sized chunks.
+    ///
+    /// # Safety
+    /// To use this safely, the caller must guarantee that the memory at `addr` is big enough for a
+    /// `T` and is available for the duration of the lifetime of the new `UnalignedRef`. The caller
+    /// must also guarantee that all other users of the given chunk of memory are using unaligned
+    /// accesses.
+    ///
+    /// # Caveat
+    /// Caller should make sure the lifetime of [`UnalignedRef`] and `addr` are matched.
+    pub unsafe fn new(addr: *mut T) -> UnalignedRef<'a, T> {
+        UnalignedRef {
+            addr,
+            phantom: PhantomData,
+        }
+    }
+
+    /// Does a unaligned write of the value `v` to the address of this ref.
+    #[inline(always)]
+    pub fn store(&self, v: T) {
+        // Safety: Assume we have a valid unaligned address with type T
+        unsafe { self.addr.write_unaligned(v) };
+    }
+
+    /// Does a unaligned read of the value at the address of this ref.
+    #[inline(always)]
+    pub fn load(&self) -> T {
+        // Safety: Assume we have a valid unaligned address with type T
+        unsafe { self.addr.read_unaligned() }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::ptr;
+
+    #[repr(packed)]
+    #[derive(Copy, Clone, Debug, PartialEq)]
+    struct Packed {
+        f1: u8,
+        f2: u16,
+    }
+
+    #[test]
+    fn unaligned_memory_test() {
+        let mut p = Packed { f1: 1, f2: 2 };
+        let unaligned_ref = unsafe { UnalignedRef::new(ptr::addr_of_mut!(p.f2)) };
+        assert_eq!(unaligned_ref.load(), 2);
+        unaligned_ref.store(500);
+        assert_eq!(p, Packed { f1: 1, f2: 500 });
+    }
+}