sh_memory now has CPageAlloc, testhookmangen.cpp contains a small test for it, GenBuffer uses CPageAlloc
(with this simple change, thesthookmangen uses 124K less memory!)
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>
29 // http://www.die.net/doc/linux/man/man2/mprotect.2.html
32 # define PAGESIZE 4096
34 # define SH_MEM_READ PROT_READ
35 # define SH_MEM_WRITE PROT_WRITE
36 # define SH_MEM_EXEC PROT_EXEC
38 // We need to align addr down to pagesize on linux
39 // We assume PAGESIZE is a power of two
40 # define SH_LALIGN(x) (void*)((intptr_t)(x) & ~(PAGESIZE-1))
41 # define SH_LALDIF(x) ((intptr_t)(x) & (PAGESIZE-1))
43 # error Unsupported OS/Compiler
50 inline bool SetMemAccess(void *addr, size_t len, int access)
53 return mprotect(SH_LALIGN(addr), len + SH_LALDIF(addr), access)==0 ? true : false;
60 prot = PAGE_READONLY; break;
61 case SH_MEM_READ | SH_MEM_WRITE:
62 prot = PAGE_READWRITE; break;
63 case SH_MEM_READ | SH_MEM_EXEC:
64 prot = PAGE_EXECUTE_READ; break;
66 case SH_MEM_READ | SH_MEM_WRITE | SH_MEM_EXEC:
67 prot = PAGE_EXECUTE_READWRITE; break;
69 return VirtualProtect(addr, len, prot, &tmp) ? true : false;
77 jmp_buf g_BadReadJmpBuf;
79 static void BadReadHandler(int sig)
82 longjmp(g_BadReadJmpBuf, 1);
88 * @brief Checks whether the specified memory region is (still) accessible
90 * @param addr The lower boundary
91 * @param len Length of the region to be checked
95 bool ModuleInMemory(char *addr, size_t len)
98 // On linux, first check /proc/self/maps
99 long lower = reinterpret_cast<long>(addr);
100 long upper = lower + len;
102 FILE *pF = fopen("/proc/self/maps", "r");
105 // Linux /proc/self/maps -> parse
107 // lower upper prot stuff path
108 // 08048000-0804c000 r-xp 00000000 03:03 1010107 /bin/cat
110 while (fscanf(pF, "%lx-%lx", &rlower, &rupper) != EOF)
112 // Check whether we're IN THERE!
113 if (lower >= rlower && upper <= rupper)
118 // Read to end of line
120 while ((c = fgetc(pF)) != '\n')
131 pF = fopen("/proc/curproc/map", "r");
134 // FreeBSD /proc/curproc/map -> parse
135 // 0x804800 0x805500 13 15 0xc6e18960 r-x 21 0x0 COW NC vnode
137 while (fscanf(pF, "0x%lx 0x%lx", &rlower, &rupper) != EOF)
139 // Check whether we're IN THERE!
140 if (lower >= rlower && upper <= rupper)
145 // Read to end of line
147 while ((c = fgetc(pF)) != '\n')
159 // Both of the above failed, try to actually read and trap sigsegv (implemented by Damaged Soul)
160 void(*prevHandler)(int sig);
161 g_BadReadCalled = true;
163 if (setjmp(g_BadReadJmpBuf))
166 prevHandler = signal(SIGSEGV, BadReadHandler);
168 volatile const char *p = reinterpret_cast<const char*>(addr);
171 for (size_t i = 0; i < len; i++)
174 g_BadReadCalled = false;
176 signal(SIGSEGV, prevHandler);
180 // On Win32, simply use IsBadReadPtr
181 return !IsBadReadPtr(addr, len);
187 Class which lets us allocate memory regions in special pages only meant for on the fly code generation.
189 If we alloc with malloc and then set the page access type to read/exec only, other regions returned by
190 malloc that are in the same page would lose their write access as well and the process could crash.
192 Allocating one page per code generation session is usually a waste of memory and on some plattforms also
193 a waste of virtual address space (Windows� VirtualAlloc has a granularity of 64K).
196 IMPORTANT: the memory that Alloc() returns is not a in a defined state!
197 It could be in read+exec OR read+write mode.
198 -> call SetRE() or SetRW() before using allocated memory!
202 struct AllocationUnit
207 AllocationUnit(size_t p_offs, size_t p_size) : begin_offset(p_offs), size(p_size)
211 bool operator < (const AllocationUnit &other) const
213 return begin_offset < other.begin_offset;
217 typedef List<AllocationUnit> AUList;
219 struct AllocatedRegion
223 bool isolated; // may contain only one AU
226 bool TryAlloc(size_t reqsize, void * &outAddr)
228 // Check for isolated
229 if (isolated && !allocUnits.empty())
232 // Find the smallest gap where req fits
234 size_t smallestgap_pos = size + 1;
235 size_t smallestgap_size = size + 1;
237 for (AUList::iterator iter = allocUnits.begin(); iter != allocUnits.end(); ++iter)
239 if (iter->begin_offset - lastend >= reqsize)
241 if (iter->begin_offset - lastend < smallestgap_size)
243 smallestgap_size = iter->begin_offset - lastend;
244 smallestgap_pos = lastend;
247 lastend = iter->begin_offset + iter->size;
250 if (size - lastend >= reqsize)
252 if (size - lastend < smallestgap_size)
254 smallestgap_size = size - lastend;
255 smallestgap_pos = lastend;
259 if (smallestgap_pos < size)
261 outAddr = reinterpret_cast<void*>(reinterpret_cast<char*>(startPtr) + smallestgap_pos);
262 allocUnits.push_sorted( AllocationUnit(smallestgap_pos, reqsize) );
271 bool TryFree(void *addr)
273 if (addr < startPtr || addr >= reinterpret_cast<void*>(reinterpret_cast<char*>(startPtr) + size))
276 size_t offs = reinterpret_cast<char*>(addr) - reinterpret_cast<char*>(startPtr);
278 for (AUList::iterator iter = allocUnits.begin(); iter != allocUnits.end(); ++iter)
280 if (iter->begin_offset == offs)
282 allocUnits.erase(iter);
290 bool Contains(void *addr)
292 return addr >= startPtr && addr < reinterpret_cast<void*>(reinterpret_cast<char*>(startPtr) + size);
298 munmap(startPtr, size);
300 VirtualFree(startPtr, 0, MEM_RELEASE);
305 typedef List<AllocatedRegion> ARList;
310 bool AddRegion(size_t minSize, bool isolated)
312 AllocatedRegion newRegion;
313 newRegion.startPtr = 0;
314 newRegion.isolated = isolated;
316 // Compute real size -> align up to m_PageSize boundary
318 newRegion.size = minSize - (minSize % m_PageSize);
319 if (newRegion.size < minSize)
320 newRegion.size += m_PageSize;
323 newRegion.startPtr = mmap(0, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAN_ANONYMOUS, -1);
325 newRegion.startPtr = VirtualAlloc(NULL, newRegion.size, MEM_COMMIT, PAGE_READWRITE);
328 if (newRegion.startPtr)
330 m_Regions.push_back(newRegion);
340 void *AllocPriv(size_t size, bool isolated)
346 for (ARList::iterator iter = m_Regions.begin(); iter != m_Regions.end(); ++iter)
348 if (iter->TryAlloc(size, addr))
353 if (!AddRegion(size, isolated))
356 bool tmp = m_Regions.back().TryAlloc(size, addr);
357 SH_ASSERT(tmp, ("TryAlloc fails after AddRegion"));
365 m_PageSize = sysconf(_SC_PAGESIZE);
368 GetSystemInfo(&sysInfo);
369 m_PageSize = sysInfo.dwPageSize;
376 for (ARList::iterator iter = m_Regions.begin(); iter != m_Regions.end(); ++iter)
382 void *Alloc(size_t size)
384 return AllocPriv(size, false);
387 void *AllocIsolated(size_t size)
389 return AllocPriv(size, true);
394 for (ARList::iterator iter = m_Regions.begin(); iter != m_Regions.end(); ++iter)
396 if (iter->TryFree(ptr))
398 if (iter->allocUnits.empty())
401 m_Regions.erase(iter);
408 void SetRE(void *ptr)
410 for (ARList::iterator iter = m_Regions.begin(); iter != m_Regions.end(); ++iter)
412 if (iter->Contains(ptr))
414 SetMemAccess(iter->startPtr, iter->size, SH_MEM_READ | SH_MEM_EXEC);
420 void SetRW(void *ptr)
422 for (ARList::iterator iter = m_Regions.begin(); iter != m_Regions.end(); ++iter)
424 if (iter->Contains(ptr))
426 SetMemAccess(iter->startPtr, iter->size, SH_MEM_READ | SH_MEM_WRITE);