lmu_shared_memory/
shared_memory.rs1use 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};