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)
48 int access = hide ? PAGE_NOACCESS : PAGE_READWRITE;
49 VirtualProtect(minefield_admin, minefield_npages * 2, access, NULL);
52 static void minefield_init(void)
58 for (size = 0x40000000; size > 0; size = ((size >> 3) * 7) & ~0xFFF) {
59 minefield_region = VirtualAlloc(NULL, size,
60 MEM_RESERVE, PAGE_NOACCESS);
64 minefield_size = size;
67 * Firstly, allocate a section of that to be the admin block.
68 * We'll need a two-byte field for each page.
70 minefield_admin = minefield_region;
71 minefield_npages = minefield_size / PAGESIZE;
72 admin_size = (minefield_npages * 2 + PAGESIZE - 1) & ~(PAGESIZE - 1);
73 minefield_npages = (minefield_size - admin_size) / PAGESIZE;
74 minefield_pages = (char *) minefield_region + admin_size;
77 * Commit the admin region.
79 VirtualAlloc(minefield_admin, minefield_npages * 2,
80 MEM_COMMIT, PAGE_READWRITE);
83 * Mark all pages as unused (0xFFFF).
85 for (i = 0; i < minefield_npages; i++)
86 minefield_admin[i] = 0xFFFF;
89 * Hide the admin region.
91 minefield_admin_hide(1);
93 minefield_initialised = 1;
96 static void minefield_bomb(void)
98 div(1, *(int *) minefield_pages);
101 static void *minefield_alloc(int size)
104 int pos, lim, region_end, region_start;
108 npages = (size + PAGESIZE - 1) / PAGESIZE;
110 minefield_admin_hide(0);
113 * Search from current position until we find a contiguous
114 * bunch of npages+2 unused pages.
116 pos = minefield_curpos;
117 lim = minefield_npages;
119 /* Skip over used pages. */
120 while (pos < lim && minefield_admin[pos] != 0xFFFF)
122 /* Count unused pages. */
124 while (pos < lim && pos - start < npages + 2 &&
125 minefield_admin[pos] == 0xFFFF)
127 if (pos - start == npages + 2)
129 /* If we've reached the limit, reset the limit or stop. */
131 if (lim == minefield_npages) {
132 /* go round and start again at zero */
133 lim = minefield_curpos;
136 minefield_admin_hide(1);
142 minefield_curpos = pos - 1;
145 * We have npages+2 unused pages starting at start. We leave
146 * the first and last of these alone and use the rest.
148 region_end = (start + npages + 1) * PAGESIZE;
149 region_start = region_end - size;
150 /* FIXME: could align here if we wanted */
153 * Update the admin region.
155 for (i = start + 2; i < start + npages - 1; i++)
156 minefield_admin[i] = 0xFFFE; /* used but no region starts here */
157 minefield_admin[start + 1] = region_start % PAGESIZE;
159 minefield_admin_hide(1);
161 VirtualAlloc((char *) minefield_pages + region_start, size,
162 MEM_COMMIT, PAGE_READWRITE);
163 return (char *) minefield_pages + region_start;
166 static void minefield_free(void *ptr)
168 int region_start, i, j;
170 minefield_admin_hide(0);
172 region_start = (char *) ptr - (char *) minefield_pages;
173 i = region_start / PAGESIZE;
174 if (i < 0 || i >= minefield_npages ||
175 minefield_admin[i] != region_start % PAGESIZE)
177 for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++) {
178 minefield_admin[j] = 0xFFFF;
181 VirtualFree(ptr, j * PAGESIZE - region_start, MEM_DECOMMIT);
183 minefield_admin_hide(1);
186 static int minefield_get_size(void *ptr)
188 int region_start, i, j;
190 minefield_admin_hide(0);
192 region_start = (char *) ptr - (char *) minefield_pages;
193 i = region_start / PAGESIZE;
194 if (i < 0 || i >= minefield_npages ||
195 minefield_admin[i] != region_start % PAGESIZE)
197 for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++);
199 minefield_admin_hide(1);
201 return j * PAGESIZE - region_start;
204 static void *minefield_c_malloc(size_t size)
206 if (!minefield_initialised)
208 return minefield_alloc(size);
211 static void minefield_c_free(void *p)
213 if (!minefield_initialised)
219 * realloc _always_ moves the chunk, for rapid detection of code
220 * that assumes it won't.
222 static void *minefield_c_realloc(void *p, size_t size)
226 if (!minefield_initialised)
228 q = minefield_alloc(size);
229 oldsize = minefield_get_size(p);
230 memcpy(q, p, (oldsize < size ? oldsize : size));
235 #endif /* MINEFIELD */
238 static FILE *fp = NULL;
240 void mlog(char *file, int line)
243 fp = fopen("putty_mem.log", "w");
244 setvbuf(fp, NULL, _IONBF, BUFSIZ);
247 fprintf(fp, "%s:%d: ", file, line);
251 void *safemalloc(size_t size)
255 p = minefield_c_malloc(size);
260 MessageBox(NULL, "Out of memory!", "PuTTY Fatal Error",
261 MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
266 fprintf(fp, "malloc(%d) returns %p\n", size, p);
271 void *saferealloc(void *ptr, size_t size)
276 p = minefield_c_malloc(size);
282 p = minefield_c_realloc(ptr, size);
284 p = realloc(ptr, size);
288 MessageBox(NULL, "Out of memory!", "PuTTY Fatal Error",
289 MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
294 fprintf(fp, "realloc(%p,%d) returns %p\n", ptr, size, p);
299 void safefree(void *ptr)
304 fprintf(fp, "free(%p)\n", ptr);
307 minefield_c_free(ptr);
314 fprintf(fp, "freeing null pointer - no action taken\n");
319 static FILE *debug_fp = NULL;
320 static int debug_got_console = 0;
322 static void dputs(char *buf)
326 if (!debug_got_console) {
328 debug_got_console = 1;
331 debug_fp = fopen("debug.log", "w");
334 WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, strlen(buf), &dw,
336 fputs(buf, debug_fp);
341 void dprintf(char *fmt, ...)
347 vsprintf(buf, fmt, ap);
353 void debug_memdump(void *buf, int len, int L)
356 unsigned char *p = buf;
360 dprintf("\t%d (0x%x) bytes:\n", len, len);
361 delta = 15 & (int) p;
365 for (; 0 < len; p += 16, len -= 16) {
369 strcpy(foo, "................"); /* sixteen dots */
370 for (i = 0; i < 16 && i < len; ++i) {
371 if (&p[i] < (unsigned char *) buf) {
372 dputs(" "); /* 3 spaces */
376 &p[i] != (unsigned char *) buf
377 && i % 4 ? '.' : ' ', p[i]
379 if (p[i] >= ' ' && p[i] <= '~')
380 foo[i] = (char) p[i];
384 dprintf("%*s%s\n", (16 - i) * 3 + 2, "", foo);
388 #endif /* def DEBUG */