xref: /llvm-project/llvm/lib/ExecutionEngine/Orc/TargetProcess/ExecutorSharedMemoryMapperService.cpp (revision 32d8d23cd0b2d4d010eb112dfe5216f11b2681f9) 
1 //===---------- ExecutorSharedMemoryMapperService.cpp -----------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "llvm/ExecutionEngine/Orc/TargetProcess/ExecutorSharedMemoryMapperService.h"
10 
11 #include "llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h"
12 #include "llvm/Support/Process.h"
13 #include "llvm/Support/WindowsError.h"
14 
15 #include <sstream>
16 
17 #if defined(LLVM_ON_UNIX)
18 #include <errno.h>
19 #include <fcntl.h>
20 #include <sys/mman.h>
21 #include <unistd.h>
22 #endif
23 
24 #if defined(_WIN32)
25 static DWORD getWindowsProtectionFlags(unsigned Flags) {
26   switch (Flags & llvm::sys::Memory::MF_RWE_MASK) {
27   case llvm::sys::Memory::MF_READ:
28     return PAGE_READONLY;
29   case llvm::sys::Memory::MF_WRITE:
30     // Note: PAGE_WRITE is not supported by VirtualProtect
31     return PAGE_READWRITE;
32   case llvm::sys::Memory::MF_READ | llvm::sys::Memory::MF_WRITE:
33     return PAGE_READWRITE;
34   case llvm::sys::Memory::MF_READ | llvm::sys::Memory::MF_EXEC:
35     return PAGE_EXECUTE_READ;
36   case llvm::sys::Memory::MF_READ | llvm::sys::Memory::MF_WRITE |
37       llvm::sys::Memory::MF_EXEC:
38     return PAGE_EXECUTE_READWRITE;
39   case llvm::sys::Memory::MF_EXEC:
40     return PAGE_EXECUTE;
41   default:
42     llvm_unreachable("Illegal memory protection flag specified!");
43   }
44   // Provide a default return value as required by some compilers.
45   return PAGE_NOACCESS;
46 }
47 #endif
48 
49 namespace llvm {
50 namespace orc {
51 namespace rt_bootstrap {
52 
53 Expected<std::pair<ExecutorAddr, std::string>>
54 ExecutorSharedMemoryMapperService::reserve(uint64_t Size) {
55 #if defined(LLVM_ON_UNIX) || defined(_WIN32)
56 
57 #if defined(LLVM_ON_UNIX)
58 
59   std::string SharedMemoryName;
60   {
61     std::stringstream SharedMemoryNameStream;
62     SharedMemoryNameStream << "/jitlink_" << sys::Process::getProcessId() << '_'
63                            << (++SharedMemoryCount);
64     SharedMemoryName = SharedMemoryNameStream.str();
65   }
66 
67   int SharedMemoryFile =
68       shm_open(SharedMemoryName.c_str(), O_RDWR | O_CREAT | O_EXCL, 0700);
69   if (SharedMemoryFile < 0)
70     return errorCodeToError(std::error_code(errno, std::generic_category()));
71 
72   // by default size is 0
73   if (ftruncate(SharedMemoryFile, Size) < 0)
74     return errorCodeToError(std::error_code(errno, std::generic_category()));
75 
76   void *Addr = mmap(nullptr, Size, PROT_NONE, MAP_SHARED, SharedMemoryFile, 0);
77   if (Addr == MAP_FAILED)
78     return errorCodeToError(std::error_code(errno, std::generic_category()));
79 
80   close(SharedMemoryFile);
81 
82 #elif defined(_WIN32)
83 
84   std::string SharedMemoryName;
85   {
86     std::stringstream SharedMemoryNameStream;
87     SharedMemoryNameStream << "jitlink_" << sys::Process::getProcessId() << '_'
88                            << (++SharedMemoryCount);
89     SharedMemoryName = SharedMemoryNameStream.str();
90   }
91 
92   std::wstring WideSharedMemoryName(SharedMemoryName.begin(),
93                                     SharedMemoryName.end());
94   HANDLE SharedMemoryFile = CreateFileMappingW(
95       INVALID_HANDLE_VALUE, NULL, PAGE_EXECUTE_READWRITE, Size >> 32,
96       Size & 0xffffffff, WideSharedMemoryName.c_str());
97   if (!SharedMemoryFile)
98     return errorCodeToError(mapWindowsError(GetLastError()));
99 
100   void *Addr = MapViewOfFile(SharedMemoryFile,
101                              FILE_MAP_ALL_ACCESS | FILE_MAP_EXECUTE, 0, 0, 0);
102   if (!Addr) {
103     CloseHandle(SharedMemoryFile);
104     return errorCodeToError(mapWindowsError(GetLastError()));
105   }
106 
107 #endif
108 
109   {
110     std::lock_guard<std::mutex> Lock(Mutex);
111     Reservations[Addr].Size = Size;
112 #if defined(_WIN32)
113     Reservations[Addr].SharedMemoryFile = SharedMemoryFile;
114 #endif
115   }
116 
117   return std::make_pair(ExecutorAddr::fromPtr(Addr),
118                         std::move(SharedMemoryName));
119 #else
120   return make_error<StringError>(
121       "SharedMemoryMapper is not supported on this platform yet",
122       inconvertibleErrorCode());
123 #endif
124 }
125 
126 Expected<ExecutorAddr>
127 ExecutorSharedMemoryMapperService::initialize(ExecutorAddr Reservation,
128                                               tpctypes::FinalizeRequest &FR) {
129 #if defined(LLVM_ON_UNIX) || defined(_WIN32)
130 
131   ExecutorAddr MinAddr(~0ULL);
132 
133   // Contents are already in place
134   for (auto &Segment : FR.Segments) {
135     if (Segment.Addr < MinAddr)
136       MinAddr = Segment.Addr;
137 
138 #if defined(LLVM_ON_UNIX)
139 
140     int NativeProt = 0;
141     if (Segment.Prot & tpctypes::WPF_Read)
142       NativeProt |= PROT_READ;
143     if (Segment.Prot & tpctypes::WPF_Write)
144       NativeProt |= PROT_WRITE;
145     if (Segment.Prot & tpctypes::WPF_Exec)
146       NativeProt |= PROT_EXEC;
147 
148     if (mprotect(Segment.Addr.toPtr<void *>(), Segment.Size, NativeProt))
149       return errorCodeToError(std::error_code(errno, std::generic_category()));
150 
151 #elif defined(_WIN32)
152 
153     DWORD NativeProt =
154         getWindowsProtectionFlags(fromWireProtectionFlags(Segment.Prot));
155 
156     if (!VirtualProtect(Segment.Addr.toPtr<void *>(), Segment.Size, NativeProt,
157                         &NativeProt))
158       return errorCodeToError(mapWindowsError(GetLastError()));
159 
160 #endif
161 
162     if (Segment.Prot & tpctypes::WPF_Exec)
163       sys::Memory::InvalidateInstructionCache(Segment.Addr.toPtr<void *>(),
164                                               Segment.Size);
165   }
166 
167   // Run finalization actions and get deinitlization action list.
168   auto DeinitializeActions = shared::runFinalizeActions(FR.Actions);
169   if (!DeinitializeActions) {
170     return DeinitializeActions.takeError();
171   }
172 
173   {
174     std::lock_guard<std::mutex> Lock(Mutex);
175     Allocations[MinAddr].DeinitializationActions =
176         std::move(*DeinitializeActions);
177     Reservations[Reservation.toPtr<void *>()].Allocations.push_back(MinAddr);
178   }
179 
180   return MinAddr;
181 
182 #else
183   return make_error<StringError>(
184       "SharedMemoryMapper is not supported on this platform yet",
185       inconvertibleErrorCode());
186 #endif
187 }
188 
189 Error ExecutorSharedMemoryMapperService::deinitialize(
190     const std::vector<ExecutorAddr> &Bases) {
191   Error AllErr = Error::success();
192 
193   {
194     std::lock_guard<std::mutex> Lock(Mutex);
195 
196     for (auto Base : Bases) {
197       if (Error Err = shared::runDeallocActions(
198               Allocations[Base].DeinitializationActions)) {
199         AllErr = joinErrors(std::move(AllErr), std::move(Err));
200       }
201 
202       Allocations.erase(Base);
203     }
204   }
205 
206   return AllErr;
207 }
208 
209 Error ExecutorSharedMemoryMapperService::release(
210     const std::vector<ExecutorAddr> &Bases) {
211 #if defined(LLVM_ON_UNIX) || defined(_WIN32)
212   Error Err = Error::success();
213 
214   for (auto Base : Bases) {
215     std::vector<ExecutorAddr> AllocAddrs;
216     size_t Size;
217 
218 #if defined(_WIN32)
219     HANDLE SharedMemoryFile;
220 #endif
221 
222     {
223       std::lock_guard<std::mutex> Lock(Mutex);
224       auto &R = Reservations[Base.toPtr<void *>()];
225       Size = R.Size;
226 
227 #if defined(_WIN32)
228       SharedMemoryFile = R.SharedMemoryFile;
229 #endif
230 
231       AllocAddrs.swap(R.Allocations);
232     }
233 
234     // deinitialize sub allocations
235     if (Error E = deinitialize(AllocAddrs))
236       Err = joinErrors(std::move(Err), std::move(E));
237 
238 #if defined(LLVM_ON_UNIX)
239 
240     if (munmap(Base.toPtr<void *>(), Size) != 0)
241       Err = joinErrors(std::move(Err), errorCodeToError(std::error_code(
242                                            errno, std::generic_category())));
243 
244 #elif defined(_WIN32)
245 
246     if (!UnmapViewOfFile(Base.toPtr<void *>()))
247       Err = joinErrors(std::move(Err),
248                        errorCodeToError(mapWindowsError(GetLastError())));
249 
250     CloseHandle(SharedMemoryFile);
251 
252 #endif
253 
254     std::lock_guard<std::mutex> Lock(Mutex);
255     Reservations.erase(Base.toPtr<void *>());
256   }
257 
258   return Err;
259 #else
260   return make_error<StringError>(
261       "SharedMemoryMapper is not supported on this platform yet",
262       inconvertibleErrorCode());
263 #endif
264 }
265 
266 Error ExecutorSharedMemoryMapperService::shutdown() {
267   std::vector<ExecutorAddr> ReservationAddrs;
268   if (!Reservations.empty()) {
269     std::lock_guard<std::mutex> Lock(Mutex);
270     {
271       ReservationAddrs.reserve(Reservations.size());
272       for (const auto &R : Reservations) {
273         ReservationAddrs.push_back(ExecutorAddr::fromPtr(R.getFirst()));
274       }
275     }
276   }
277   return release(ReservationAddrs);
278 
279   return Error::success();
280 }
281 
282 void ExecutorSharedMemoryMapperService::addBootstrapSymbols(
283     StringMap<ExecutorAddr> &M) {
284   M[rt::ExecutorSharedMemoryMapperServiceInstanceName] =
285       ExecutorAddr::fromPtr(this);
286   M[rt::ExecutorSharedMemoryMapperServiceReserveWrapperName] =
287       ExecutorAddr::fromPtr(&reserveWrapper);
288   M[rt::ExecutorSharedMemoryMapperServiceInitializeWrapperName] =
289       ExecutorAddr::fromPtr(&initializeWrapper);
290   M[rt::ExecutorSharedMemoryMapperServiceDeinitializeWrapperName] =
291       ExecutorAddr::fromPtr(&deinitializeWrapper);
292   M[rt::ExecutorSharedMemoryMapperServiceReleaseWrapperName] =
293       ExecutorAddr::fromPtr(&releaseWrapper);
294 }
295 
296 llvm::orc::shared::CWrapperFunctionResult
297 ExecutorSharedMemoryMapperService::reserveWrapper(const char *ArgData,
298                                                   size_t ArgSize) {
299   return shared::WrapperFunction<
300              rt::SPSExecutorSharedMemoryMapperServiceReserveSignature>::
301       handle(ArgData, ArgSize,
302              shared::makeMethodWrapperHandler(
303                  &ExecutorSharedMemoryMapperService::reserve))
304           .release();
305 }
306 
307 llvm::orc::shared::CWrapperFunctionResult
308 ExecutorSharedMemoryMapperService::initializeWrapper(const char *ArgData,
309                                                      size_t ArgSize) {
310   return shared::WrapperFunction<
311              rt::SPSExecutorSharedMemoryMapperServiceInitializeSignature>::
312       handle(ArgData, ArgSize,
313              shared::makeMethodWrapperHandler(
314                  &ExecutorSharedMemoryMapperService::initialize))
315           .release();
316 }
317 
318 llvm::orc::shared::CWrapperFunctionResult
319 ExecutorSharedMemoryMapperService::deinitializeWrapper(const char *ArgData,
320                                                        size_t ArgSize) {
321   return shared::WrapperFunction<
322              rt::SPSExecutorSharedMemoryMapperServiceDeinitializeSignature>::
323       handle(ArgData, ArgSize,
324              shared::makeMethodWrapperHandler(
325                  &ExecutorSharedMemoryMapperService::deinitialize))
326           .release();
327 }
328 
329 llvm::orc::shared::CWrapperFunctionResult
330 ExecutorSharedMemoryMapperService::releaseWrapper(const char *ArgData,
331                                                   size_t ArgSize) {
332   return shared::WrapperFunction<
333              rt::SPSExecutorSharedMemoryMapperServiceReleaseSignature>::
334       handle(ArgData, ArgSize,
335              shared::makeMethodWrapperHandler(
336                  &ExecutorSharedMemoryMapperService::release))
337           .release();
338 }
339 
340 } // namespace rt_bootstrap
341 } // end namespace orc
342 } // end namespace llvm
343