Skip to main content

lmu_shared_memory/
shared_memory.rs

1use crate::{Error, Result};
2
3#[cfg(windows)]
4mod platform {
5    use std::sync::atomic::{AtomicI32, Ordering};
6
7    use super::*;
8    use windows::{
9        Win32::{
10            Foundation::{CloseHandle, HANDLE, HWND, INVALID_HANDLE_VALUE},
11            System::{
12                Memory::{
13                    CreateFileMappingW, FILE_MAP_ALL_ACCESS, FILE_MAP_READ,
14                    MEMORY_MAPPED_VIEW_ADDRESS, MapViewOfFile, OpenFileMappingW, PAGE_READWRITE,
15                    UnmapViewOfFile,
16                },
17                Threading::{CreateEventW, SetEvent},
18            },
19            UI::WindowsAndMessaging::IsWindow,
20        },
21        core::HSTRING,
22    };
23
24    const LOCK_MAPPING_NAME: &str = "LMU_SharedMemoryLockData";
25    const LOCK_EVENT_NAME: &str = "LMU_SharedMemoryLockEvent";
26    const LOCK_DATA_SIZE: usize = 8;
27    const MAX_LOCK_SPINS: usize = 64;
28
29    pub struct SharedMemory {
30        name: String,
31        handle: HANDLE,
32        view: MEMORY_MAPPED_VIEW_ADDRESS,
33        size: usize,
34    }
35
36    impl SharedMemory {
37        pub fn open(name: &str, size: usize) -> Result<Self> {
38            let name_wide = HSTRING::from(name);
39            let handle = unsafe { OpenFileMappingW(FILE_MAP_READ.0, false, &name_wide) }.map_err(
40                |error| Error::SharedMemoryUnavailable {
41                    name: name.into(),
42                    source: error.to_string(),
43                },
44            )?;
45            let view = unsafe { MapViewOfFile(handle, FILE_MAP_READ, 0, 0, size) };
46            if view.Value.is_null() {
47                let _ = unsafe { CloseHandle(handle) };
48                return Err(Error::MapViewFailed { name: name.into() });
49            }
50            Ok(Self {
51                name: name.into(),
52                handle,
53                view,
54                size,
55            })
56        }
57        pub fn read<T: Copy>(&self, offset: usize) -> Result<T> {
58            let value_size = std::mem::size_of::<T>();
59            if offset
60                .checked_add(value_size)
61                .is_none_or(|end| end > self.size)
62            {
63                return Err(Error::OutOfBounds {
64                    name: self.name.clone(),
65                    offset,
66                    value_size,
67                    mapping_size: self.size,
68                });
69            }
70            let pointer = unsafe { self.view.Value.cast::<u8>().add(offset).cast::<T>() };
71            Ok(unsafe { pointer.read_unaligned() })
72        }
73        pub fn len(&self) -> usize {
74            self.size
75        }
76        pub fn is_empty(&self) -> bool {
77            self.size == 0
78        }
79    }
80    impl Drop for SharedMemory {
81        fn drop(&mut self) {
82            let _ = unsafe { UnmapViewOfFile(self.view) };
83            let _ = unsafe { CloseHandle(self.handle) };
84        }
85    }
86    unsafe impl Send for SharedMemory {}
87    unsafe impl Sync for SharedMemory {}
88
89    pub fn source_window_alive(raw: u64) -> bool {
90        raw != 0 && unsafe { IsWindow(Some(HWND(raw as usize as *mut _))).as_bool() }
91    }
92
93    pub struct SharedMemoryLock {
94        handle: HANDLE,
95        view: MEMORY_MAPPED_VIEW_ADDRESS,
96        event: HANDLE,
97    }
98    impl SharedMemoryLock {
99        pub fn open() -> Result<Self> {
100            let mapping = HSTRING::from(LOCK_MAPPING_NAME);
101            let handle = unsafe {
102                CreateFileMappingW(
103                    INVALID_HANDLE_VALUE,
104                    None,
105                    PAGE_READWRITE,
106                    0,
107                    LOCK_DATA_SIZE as u32,
108                    &mapping,
109                )
110            }
111            .map_err(|error| Error::SharedMemoryUnavailable {
112                name: LOCK_MAPPING_NAME.into(),
113                source: error.to_string(),
114            })?;
115            let view = unsafe { MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, LOCK_DATA_SIZE) };
116            if view.Value.is_null() {
117                let _ = unsafe { CloseHandle(handle) };
118                return Err(Error::MapViewFailed {
119                    name: LOCK_MAPPING_NAME.into(),
120                });
121            }
122            let event =
123                unsafe { CreateEventW(None, false, false, &HSTRING::from(LOCK_EVENT_NAME)) }
124                    .map_err(|error| Error::SharedMemoryUnavailable {
125                        name: LOCK_EVENT_NAME.into(),
126                        source: error.to_string(),
127                    })?;
128            Ok(Self {
129                handle,
130                view,
131                event,
132            })
133        }
134        pub fn try_lock(&self) -> Option<SharedMemoryGuard<'_>> {
135            for _ in 0..MAX_LOCK_SPINS {
136                if self
137                    .busy()
138                    .compare_exchange(0, 1, Ordering::Acquire, Ordering::Relaxed)
139                    .is_ok()
140                {
141                    return Some(SharedMemoryGuard { lock: self });
142                }
143                std::hint::spin_loop();
144            }
145            None
146        }
147        fn waiters(&self) -> &AtomicI32 {
148            unsafe { &*self.view.Value.cast::<AtomicI32>() }
149        }
150        fn busy(&self) -> &AtomicI32 {
151            unsafe { &*self.view.Value.cast::<u8>().add(4).cast::<AtomicI32>() }
152        }
153    }
154    impl Drop for SharedMemoryLock {
155        fn drop(&mut self) {
156            let _ = unsafe { CloseHandle(self.event) };
157            let _ = unsafe { UnmapViewOfFile(self.view) };
158            let _ = unsafe { CloseHandle(self.handle) };
159        }
160    }
161    unsafe impl Send for SharedMemoryLock {}
162    unsafe impl Sync for SharedMemoryLock {}
163    pub struct SharedMemoryGuard<'a> {
164        lock: &'a SharedMemoryLock,
165    }
166    impl Drop for SharedMemoryGuard<'_> {
167        fn drop(&mut self) {
168            self.lock.busy().store(0, Ordering::Release);
169            if self.lock.waiters().load(Ordering::Acquire) > 0 {
170                let _ = unsafe { SetEvent(self.lock.event) };
171            }
172        }
173    }
174}
175
176#[cfg(not(windows))]
177mod platform {
178    use super::*;
179    pub struct SharedMemory;
180    pub struct SharedMemoryLock;
181    pub struct SharedMemoryGuard;
182    pub fn source_window_alive(_: u64) -> bool {
183        false
184    }
185    impl SharedMemory {
186        pub fn open(_: &str, _: usize) -> Result<Self> {
187            Err(Error::UnsupportedPlatform)
188        }
189        pub fn read<T: Copy>(&self, _: usize) -> Result<T> {
190            Err(Error::UnsupportedPlatform)
191        }
192        pub fn len(&self) -> usize {
193            0
194        }
195        pub fn is_empty(&self) -> bool {
196            true
197        }
198    }
199    impl SharedMemoryLock {
200        pub fn open() -> Result<Self> {
201            Err(Error::UnsupportedPlatform)
202        }
203        pub fn try_lock(&self) -> Option<SharedMemoryGuard> {
204            None
205        }
206    }
207}
208
209pub(crate) use platform::source_window_alive;
210pub use platform::{SharedMemory, SharedMemoryGuard, SharedMemoryLock};