7 * My own versions of malloc, realloc and free. Because I want
8 * malloc and realloc to bomb out and exit the program if they run
9 * out of memory, realloc to reliably call malloc if passed a NULL
10 * pointer, and free to reliably do nothing if passed a NULL
11 * pointer. We can also put trace printouts in, if we need to; and
12 * we can also replace the allocator with an ElectricFence-like
18 * Minefield - a Windows equivalent for Electric Fence
26 * We start by reserving as much virtual address space as Windows
27 * will sensibly (or not sensibly) let us have. We flag it all as
30 * Any allocation attempt is satisfied by committing one or more
31 * pages, with an uncommitted page on either side. The returned
32 * memory region is jammed up against the _end_ of the pages.
34 * Freeing anything causes instantaneous decommitment of the pages
35 * involved, so stale pointers are caught as soon as possible.
38 static int minefield_initialised = 0;
39 static void *minefield_region = NULL;
40 static long minefield_size = 0;
41 static long minefield_npages = 0;
42 static long minefield_curpos = 0;
43 static unsigned short *minefield_admin = NULL;
44 static void *minefield_pages = NULL;
46 static void minefield_admin_hide(int hide) {
47 int access = hide ? PAGE_NOACCESS : PAGE_READWRITE;
48 VirtualProtect(minefield_admin, minefield_npages*2, access, NULL);
51 static void minefield_init(void) {
56 for (size = 0x40000000; size > 0; size = ((size >> 3) * 7) &~ 0xFFF) {
57 minefield_region = VirtualAlloc(NULL, size,
58 MEM_RESERVE, PAGE_NOACCESS);
62 minefield_size = size;
65 * Firstly, allocate a section of that to be the admin block.
66 * We'll need a two-byte field for each page.
68 minefield_admin = minefield_region;
69 minefield_npages = minefield_size / PAGESIZE;
70 admin_size = (minefield_npages * 2 + PAGESIZE-1) &~ (PAGESIZE-1);
71 minefield_npages = (minefield_size - admin_size) / PAGESIZE;
72 minefield_pages = (char *)minefield_region + admin_size;
75 * Commit the admin region.
77 VirtualAlloc(minefield_admin, minefield_npages * 2,
78 MEM_COMMIT, PAGE_READWRITE);
81 * Mark all pages as unused (0xFFFF).
83 for (i = 0; i < minefield_npages; i++)
84 minefield_admin[i] = 0xFFFF;
87 * Hide the admin region.
89 minefield_admin_hide(1);
91 minefield_initialised = 1;
94 static void minefield_bomb(void) {
95 div(1, *(int*)minefield_pages);
98 static void *minefield_alloc(int size) {
100 int pos, lim, region_end, region_start;
104 npages = (size + PAGESIZE-1) / PAGESIZE;
106 minefield_admin_hide(0);
109 * Search from current position until we find a contiguous
110 * bunch of npages+2 unused pages.
112 pos = minefield_curpos;
113 lim = minefield_npages;
115 /* Skip over used pages. */
116 while (pos < lim && minefield_admin[pos] != 0xFFFF)
118 /* Count unused pages. */
120 while (pos < lim && pos - start < npages+2 &&
121 minefield_admin[pos] == 0xFFFF)
123 if (pos - start == npages+2)
125 /* If we've reached the limit, reset the limit or stop. */
127 if (lim == minefield_npages) {
128 /* go round and start again at zero */
129 lim = minefield_curpos;
132 minefield_admin_hide(1);
138 minefield_curpos = pos-1;
141 * We have npages+2 unused pages starting at start. We leave
142 * the first and last of these alone and use the rest.
144 region_end = (start + npages+1) * PAGESIZE;
145 region_start = region_end - size;
146 /* FIXME: could align here if we wanted */
149 * Update the admin region.
151 for (i = start + 2; i < start + npages-1; i++)
152 minefield_admin[i] = 0xFFFE; /* used but no region starts here */
153 minefield_admin[start+1] = region_start % PAGESIZE;
155 minefield_admin_hide(1);
157 VirtualAlloc((char *)minefield_pages + region_start, size,
158 MEM_COMMIT, PAGE_READWRITE);
159 return (char *)minefield_pages + region_start;
162 static void minefield_free(void *ptr) {
163 int region_start, i, j;
165 minefield_admin_hide(0);
167 region_start = (char *)ptr - (char *)minefield_pages;
168 i = region_start / PAGESIZE;
169 if (i < 0 || i >= minefield_npages ||
170 minefield_admin[i] != region_start % PAGESIZE)
172 for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++) {
173 minefield_admin[j] = 0xFFFF;
176 VirtualFree(ptr, j*PAGESIZE - region_start, MEM_DECOMMIT);
178 minefield_admin_hide(1);
181 static int minefield_get_size(void *ptr) {
182 int region_start, i, j;
184 minefield_admin_hide(0);
186 region_start = (char *)ptr - (char *)minefield_pages;
187 i = region_start / PAGESIZE;
188 if (i < 0 || i >= minefield_npages ||
189 minefield_admin[i] != region_start % PAGESIZE)
191 for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++);
193 minefield_admin_hide(1);
195 return j*PAGESIZE - region_start;
198 static void *minefield_c_malloc(size_t size) {
199 if (!minefield_initialised) minefield_init();
200 return minefield_alloc(size);
203 static void minefield_c_free(void *p) {
204 if (!minefield_initialised) minefield_init();
209 * realloc _always_ moves the chunk, for rapid detection of code
210 * that assumes it won't.
212 static void *minefield_c_realloc(void *p, size_t size) {
215 if (!minefield_initialised) minefield_init();
216 q = minefield_alloc(size);
217 oldsize = minefield_get_size(p);
218 memcpy(q, p, (oldsize < size ? oldsize : size));
223 #endif /* MINEFIELD */
226 static FILE *fp = NULL;
228 void mlog(char *file, int line) {
230 fp = fopen("putty_mem.log", "w");
231 setvbuf(fp, NULL, _IONBF, BUFSIZ);
234 fprintf (fp, "%s:%d: ", file, line);
238 void *safemalloc(size_t size) {
241 p = minefield_c_malloc (size);
246 MessageBox(NULL, "Out of memory!", "PuTTY Fatal Error",
247 MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
252 fprintf(fp, "malloc(%d) returns %p\n", size, p);
257 void *saferealloc(void *ptr, size_t size) {
261 p = minefield_c_malloc (size);
267 p = minefield_c_realloc (ptr, size);
269 p = realloc (ptr, size);
273 MessageBox(NULL, "Out of memory!", "PuTTY Fatal Error",
274 MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
279 fprintf(fp, "realloc(%p,%d) returns %p\n", ptr, size, p);
284 void safefree(void *ptr) {
288 fprintf(fp, "free(%p)\n", ptr);
291 minefield_c_free (ptr);
298 fprintf(fp, "freeing null pointer - no action taken\n");
303 static FILE *debug_fp = NULL;
304 static int debug_got_console = 0;
306 void dprintf(char *fmt, ...) {
311 if (!debug_got_console) {
313 debug_got_console = 1;
316 debug_fp = fopen("debug.log", "w");
320 vsprintf(buf, fmt, ap);
321 WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, strlen(buf), &dw, NULL);
322 fputs(buf, debug_fp);