Some refinement

Signed-off-by: Narfinger <[email protected]>

Author: Narfinger

Cargo.toml

@@ -41,7 +41,7 @@ fnv = "1.0.3"
 futures-channel = { version = "0.3.31", optional = true }
 futures-core = { version = "0.3.31", optional = true }
 libc = "0.2.162"
-serde_core = "1.0"
+serde = { version = "1.0", features = ["derive"] }
 uuid = { version = "1", features = ["v4"] }
 
 [target.'cfg(any(target_os = "linux", target_os = "openbsd", target_os = "freebsd", target_os = "illumos"))'.dependencies]

src/ipc.rs

@@ -16,7 +16,7 @@ use crate::platform::{
 };
 
 use bincode;
-use serde_core::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
+use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
 use std::cell::RefCell;
 use std::cmp::min;
 use std::error::Error as StdError;
@@ -643,7 +643,7 @@ impl IpcSharedMemory {
 }
 
 /// An index to access `IpcSharedMemoryVec`
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct IpcSharedMemoryIndex(OsIpcSharedMemoryIndex);
 
 /// Shared memory vector that will can be made accessible to a receiver via the reader method
@@ -664,6 +664,18 @@ pub struct IpcSharedMemoryVec {
     os_shared_memory_vec: OsIpcSharedMemoryVec,
 }
 
+unsafe impl Send for IpcSharedMemoryVec {}
+unsafe impl Sync for IpcSharedMemoryVec {}
+
+impl Default for IpcSharedMemoryVec {
+    fn default() -> Self {
+        let (memory, _index) = OsIpcSharedMemoryVec::from_bytes(&[0xab]);
+        IpcSharedMemoryVec {
+            os_shared_memory_vec: memory,
+        }
+    }
+}
+
 impl IpcSharedMemoryVec {
     pub fn from_bytes(bytes: &[u8]) -> (IpcSharedMemoryVec, IpcSharedMemoryIndex) {
         let (memory, index) = OsIpcSharedMemoryVec::from_bytes(bytes);

src/platform/unix/mod.rs

@@ -11,15 +11,16 @@ use crate::ipc::{self, IpcMessage};
 use bincode;
 use fnv::FnvHasher;
 use libc::{
-    self, cmsghdr, linger, CMSG_DATA, CMSG_LEN, CMSG_SPACE, MAP_FAILED, MAP_SHARED, PROT_READ,
-    PROT_WRITE, SOCK_SEQPACKET, SOL_SOCKET,
+    self, cmsghdr, linger, CMSG_DATA, CMSG_LEN, CMSG_SPACE, MAP_FAILED, MAP_FIXED, MAP_NORESERVE,
+    MAP_SHARED, PROT_READ, PROT_WRITE, SOCK_SEQPACKET, SOL_SOCKET,
 };
 use libc::{c_char, c_int, c_void, getsockopt, SO_LINGER, S_IFMT, S_IFSOCK};
 use libc::{iovec, msghdr, off_t, recvmsg, sendmsg};
 use libc::{sa_family_t, setsockopt, size_t, sockaddr, sockaddr_un, socketpair, socklen_t};
 use libc::{EAGAIN, EWOULDBLOCK};
 use mio::unix::SourceFd;
 use mio::{Events, Interest, Poll, Token};
+use serde::{Deserialize, Serialize};
 use std::cell::Cell;
 use std::cmp;
 use std::collections::HashMap;
@@ -811,6 +812,31 @@ impl BackingStore {
         assert!(address != MAP_FAILED);
         (address as *mut u8, length)
     }
+
+    pub unsafe fn map_file_noreserve(&self, length: Option<size_t>) -> (*mut u8, size_t) {
+        let length = length.unwrap_or_else(|| {
+            let mut st = mem::MaybeUninit::uninit();
+            if libc::fstat(self.fd, st.as_mut_ptr()) != 0 {
+                panic!("error stating fd {}: {}", self.fd, UnixError::last());
+            }
+            st.assume_init().st_size as size_t
+        });
+        if length == 0 {
+            // This will cause `mmap` to fail, so handle it explicitly.
+            return (ptr::null_mut(), length);
+        }
+        let address = libc::mmap(
+            ptr::null_mut(),
+            length,
+            PROT_READ | PROT_WRITE,
+            MAP_SHARED | MAP_NORESERVE,
+            self.fd,
+            0,
+        );
+        assert!(!address.is_null());
+        assert!(address != MAP_FAILED);
+        (address as *mut u8, length)
+    }
 }
 
 impl Drop for BackingStore {
@@ -822,7 +848,7 @@ impl Drop for BackingStore {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct OsIpcSharedMemoryIndex {
     // The offset in bytes
     offset: usize,
@@ -840,7 +866,7 @@ impl OsIpcSharedMemoryVec {
     pub fn from_bytes(bytes: &[u8]) -> (OsIpcSharedMemoryVec, OsIpcSharedMemoryIndex) {
         unsafe {
             let store = BackingStore::new(bytes.len());
-            let (address, _) = store.map_file(Some(bytes.len()));
+            let (address, _) = store.map_file_noreserve(Some(512_000_000));
             ptr::copy_nonoverlapping(bytes.as_ptr(), address, bytes.len());
             let memory = OsIpcSharedMemoryVec {
                 ptr: address,
@@ -866,7 +892,21 @@ impl OsIpcSharedMemoryVec {
     pub fn push(&mut self, bytes: &[u8]) -> OsIpcSharedMemoryIndex {
         let fd = self.store.fd();
         let index = unsafe {
-            libc::ftruncate(fd, (self.length + bytes.len()).try_into().unwrap());
+            assert_eq!(
+                0,
+                libc::ftruncate(fd, (self.length + bytes.len()).try_into().unwrap())
+            );
+
+            let new_length = self.length + bytes.len();
+            // map more of the file into the address space
+            let address = libc::mmap(
+                self.ptr.byte_offset(self.length.try_into().unwrap()) as *mut c_void,
+                bytes.len(),
+                PROT_READ | PROT_WRITE,
+                MAP_SHARED | MAP_FIXED,
+                self.store.fd,
+                0,
+            );
             ptr::copy_nonoverlapping(
                 bytes.as_ptr(),
                 self.ptr.byte_offset(self.length as isize),
@@ -882,6 +922,11 @@ impl OsIpcSharedMemoryVec {
     }
 
     pub fn get(&self, index: &OsIpcSharedMemoryIndex) -> &[u8] {
+        // While it would be nice to check index vs length here, we cannot.
+        // The length in this object might be a reader that was sent a long time ago
+        // The length does not get updated for the object, only for the main IpcSharedMemoryVec
+        // This is in general fine as we only produce indices for objects that exists _and_ we
+        // can never delete objects.
         unsafe {
             slice::from_raw_parts(
                 self.ptr.byte_offset(index.offset.try_into().unwrap()),

src/router.rs

@@ -18,7 +18,7 @@ use std::sync::{LazyLock, Mutex};
 use std::thread::{self, JoinHandle};
 
 use crossbeam_channel::{self, Receiver, Sender};
-use serde_core::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize};
 
 use crate::ipc::{
     self, IpcMessage, IpcReceiver, IpcReceiverSet, IpcSelectionResult, IpcSender, OpaqueIpcReceiver,

src/test.rs

@@ -544,11 +544,15 @@ fn shared_memory_object_equality() {
 
 #[test]
 fn shared_memory_vec() {
-    let (vec, index) = IpcSharedMemoryVec::from_bytes(&[0xba; 24]);
+    let (mut vec, index) = IpcSharedMemoryVec::from_bytes(&[0xba; 24]);
     let (tx, rx) = ipc::channel().unwrap();
     tx.send(vec.reader()).unwrap();
     let received = rx.recv().unwrap();
     assert_eq!(vec.get(&index), received.get(&index));
+
+    let index2 = vec.push(&[0xbc; 24]);
+    assert_eq!(vec.get(&index2), received.get(&index2));
+    assert_eq!(vec.get(&index), received.get(&index));
 }
 
 #[test]