1 /* ======== SourceHook ========
2 * Copyright (C) 2004-2007 Metamod:Source Development Team
3 * No warranties of any kind
7 * Author(s): Pavol "PM OnoTo" Marko, Scott "Damaged Soul" Ehlert
8 * Contributors: lancevorgin, XAD, theqizmo
9 * ============================
12 #ifndef __SHINT_MEMORY_H__
13 #define __SHINT_MEMORY_H__
16 // Unprotect now sets to readwrite
17 // The vtable doesn't need to be executable anyway
19 # if /********/ defined _WIN32
21 # define SH_MEM_READ 1
22 # define SH_MEM_WRITE 2
23 # define SH_MEM_EXEC 4
24 # elif /******/ defined __linux__
25 # include <sys/mman.h>
32 // http://www.die.net/doc/linux/man/man2/mprotect.2.html
35 # define PAGESIZE 4096
37 # define SH_MEM_READ PROT_READ
38 # define SH_MEM_WRITE PROT_WRITE
39 # define SH_MEM_EXEC PROT_EXEC
41 // We need to align addr down to pagesize on linux
42 // We assume PAGESIZE is a power of two
43 # define SH_LALIGN(x) (void*)((intptr_t)(x) & ~(PAGESIZE-1))
44 # define SH_LALDIF(x) ((intptr_t)(x) & (PAGESIZE-1))
46 # error Unsupported OS/Compiler
53 inline bool SetMemAccess(void *addr, size_t len, int access)
56 return mprotect(SH_LALIGN(addr), len + SH_LALDIF(addr), access)==0 ? true : false;
63 prot = PAGE_READONLY; break;
64 case SH_MEM_READ | SH_MEM_WRITE:
65 prot = PAGE_READWRITE; break;
66 case SH_MEM_READ | SH_MEM_EXEC:
67 prot = PAGE_EXECUTE_READ; break;
69 case SH_MEM_READ | SH_MEM_WRITE | SH_MEM_EXEC:
70 prot = PAGE_EXECUTE_READWRITE; break;
72 return VirtualProtect(addr, len, prot, &tmp) ? true : false;
80 jmp_buf g_BadReadJmpBuf;
82 static void BadReadHandler(int sig)
85 longjmp(g_BadReadJmpBuf, 1);
91 * @brief Checks whether the specified memory region is (still) accessible
93 * @param addr The lower boundary
94 * @param len Length of the region to be checked
98 bool ModuleInMemory(char *addr, size_t len)
101 // On linux, first check /proc/self/maps
102 long lower = reinterpret_cast<long>(addr);
103 long upper = lower + len;
105 FILE *pF = fopen("/proc/self/maps", "r");
108 // Linux /proc/self/maps -> parse
110 // lower upper prot stuff path
111 // 08048000-0804c000 r-xp 00000000 03:03 1010107 /bin/cat
113 while (fscanf(pF, "%lx-%lx", &rlower, &rupper) != EOF)
115 // Check whether we're IN THERE!
116 if (lower >= rlower && upper <= rupper)
121 // Read to end of line
123 while ((c = fgetc(pF)) != '\n')
134 pF = fopen("/proc/curproc/map", "r");
137 // FreeBSD /proc/curproc/map -> parse
138 // 0x804800 0x805500 13 15 0xc6e18960 r-x 21 0x0 COW NC vnode
140 while (fscanf(pF, "0x%lx 0x%lx", &rlower, &rupper) != EOF)
142 // Check whether we're IN THERE!
143 if (lower >= rlower && upper <= rupper)
148 // Read to end of line
150 while ((c = fgetc(pF)) != '\n')
162 // Both of the above failed, try to actually read and trap sigsegv (implemented by Damaged Soul)
163 void(*prevHandler)(int sig);
164 g_BadReadCalled = true;
166 if (setjmp(g_BadReadJmpBuf))
169 prevHandler = LinuxSignal::signal(SIGSEGV, BadReadHandler);
171 volatile const char *p = reinterpret_cast<const char*>(addr);
174 for (size_t i = 0; i < len; i++)
177 g_BadReadCalled = false;
179 LinuxSignal::signal(SIGSEGV, prevHandler);
183 // On Win32, simply use IsBadReadPtr
184 return !IsBadReadPtr(addr, len);
190 Class which lets us allocate memory regions in special pages only meant for on the fly code generation.
192 If we alloc with malloc and then set the page access type to read/exec only, other regions returned by
193 malloc that are in the same page would lose their write access as well and the process could crash.
195 Allocating one page per code generation session is usually a waste of memory and on some plattforms also
196 a waste of virtual address space (Windows� VirtualAlloc has a granularity of 64K).
199 IMPORTANT: the memory that Alloc() returns is not a in a defined state!
200 It could be in read+exec OR read+write mode.
201 -> call SetRE() or SetRW() before using allocated memory!
205 struct AllocationUnit
210 AllocationUnit(size_t p_offs, size_t p_size) : begin_offset(p_offs), size(p_size)
214 bool operator < (const AllocationUnit &other) const
216 return begin_offset < other.begin_offset;
220 typedef List<AllocationUnit> AUList;
222 struct AllocatedRegion
226 bool isolated; // may contain only one AU
229 bool TryAlloc(size_t reqsize, void * &outAddr)
231 // Check for isolated
232 if (isolated && !allocUnits.empty())
235 // Find the smallest gap where req fits
237 size_t smallestgap_pos = size + 1;
238 size_t smallestgap_size = size + 1;
240 for (AUList::iterator iter = allocUnits.begin(); iter != allocUnits.end(); ++iter)
242 if (iter->begin_offset - lastend >= reqsize)
244 if (iter->begin_offset - lastend < smallestgap_size)
246 smallestgap_size = iter->begin_offset - lastend;
247 smallestgap_pos = lastend;
250 lastend = iter->begin_offset + iter->size;
253 if (size - lastend >= reqsize)
255 if (size - lastend < smallestgap_size)
257 smallestgap_size = size - lastend;
258 smallestgap_pos = lastend;
262 if (smallestgap_pos < size)
264 outAddr = reinterpret_cast<void*>(reinterpret_cast<char*>(startPtr) + smallestgap_pos);
265 allocUnits.push_sorted( AllocationUnit(smallestgap_pos, reqsize) );
274 bool TryFree(void *addr)
276 if (addr < startPtr || addr >= reinterpret_cast<void*>(reinterpret_cast<char*>(startPtr) + size))
279 size_t offs = reinterpret_cast<char*>(addr) - reinterpret_cast<char*>(startPtr);
281 for (AUList::iterator iter = allocUnits.begin(); iter != allocUnits.end(); ++iter)
283 if (iter->begin_offset == offs)
285 allocUnits.erase(iter);
293 bool Contains(void *addr)
295 return addr >= startPtr && addr < reinterpret_cast<void*>(reinterpret_cast<char*>(startPtr) + size);
301 munmap(startPtr, size);
303 VirtualFree(startPtr, 0, MEM_RELEASE);
308 typedef List<AllocatedRegion> ARList;
313 bool AddRegion(size_t minSize, bool isolated)
315 AllocatedRegion newRegion;
316 newRegion.startPtr = 0;
317 newRegion.isolated = isolated;
319 // Compute real size -> align up to m_PageSize boundary
321 newRegion.size = minSize - (minSize % m_PageSize);
322 if (newRegion.size < minSize)
323 newRegion.size += m_PageSize;
326 newRegion.startPtr = mmap(0, newRegion.size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
328 newRegion.startPtr = VirtualAlloc(NULL, newRegion.size, MEM_COMMIT, PAGE_READWRITE);
331 if (newRegion.startPtr)
333 m_Regions.push_back(newRegion);
343 void *AllocPriv(size_t size, bool isolated)
349 for (ARList::iterator iter = m_Regions.begin(); iter != m_Regions.end(); ++iter)
351 if (iter->TryAlloc(size, addr))
356 if (!AddRegion(size, isolated))
359 bool tmp = m_Regions.back().TryAlloc(size, addr);
360 SH_ASSERT(tmp, ("TryAlloc fails after AddRegion"));
368 m_PageSize = sysconf(_SC_PAGESIZE);
371 GetSystemInfo(&sysInfo);
372 m_PageSize = sysInfo.dwPageSize;
379 for (ARList::iterator iter = m_Regions.begin(); iter != m_Regions.end(); ++iter)
385 void *Alloc(size_t size)
387 return AllocPriv(size, false);
390 void *AllocIsolated(size_t size)
392 return AllocPriv(size, true);
397 for (ARList::iterator iter = m_Regions.begin(); iter != m_Regions.end(); ++iter)
399 if (iter->TryFree(ptr))
401 if (iter->allocUnits.empty())
404 m_Regions.erase(iter);
411 void SetRE(void *ptr)
413 for (ARList::iterator iter = m_Regions.begin(); iter != m_Regions.end(); ++iter)
415 if (iter->Contains(ptr))
417 SetMemAccess(iter->startPtr, iter->size, SH_MEM_READ | SH_MEM_EXEC);
423 void SetRW(void *ptr)
425 for (ARList::iterator iter = m_Regions.begin(); iter != m_Regions.end(); ++iter)
427 if (iter->Contains(ptr))
429 SetMemAccess(iter->startPtr, iter->size, SH_MEM_READ | SH_MEM_WRITE);