]> asedeno.scripts.mit.edu Git - PuTTY.git/blob - misc.c
Added Minefield: an alternative memory allocator along the lines of
[PuTTY.git] / misc.c
1 #include <windows.h>
2 #include <stdio.h>
3 #include <stdlib.h>
4 #include "putty.h"
5
6 /*
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
13  * one.
14  */
15
16 #ifdef MINEFIELD
17 /*
18  * Minefield - a Windows equivalent for Electric Fence
19  */
20
21 #define PAGESIZE 4096
22
23 /*
24  * Design:
25  * 
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
28  * invalid memory.
29  * 
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.
33  * 
34  * Freeing anything causes instantaneous decommitment of the pages
35  * involved, so stale pointers are caught as soon as possible.
36  */
37
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;
45
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);
49 }
50
51 static void minefield_init(void) {
52     int size;
53     int admin_size;
54     int i;
55
56     for (size = 0x40000000; size > 0; size = ((size >> 3) * 7) &~ 0xFFF) {
57         printf("trying size=%d\n", size);
58         minefield_region = VirtualAlloc(NULL, size,
59                                         MEM_RESERVE, PAGE_NOACCESS);
60         if (minefield_region)
61             break;
62     }
63     minefield_size = size;
64     printf("got region %p size %d\n", minefield_region, minefield_size);
65
66     /*
67      * Firstly, allocate a section of that to be the admin block.
68      * We'll need a two-byte field for each page.
69      */
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;
75     printf("admin at %p, pages at %p, npages %x, admin_size %x\n",
76            minefield_admin, minefield_pages, minefield_npages,
77            admin_size);
78
79     /*
80      * Commit the admin region.
81      */
82     VirtualAlloc(minefield_admin, minefield_npages * 2,
83                  MEM_COMMIT, PAGE_READWRITE);
84
85     /*
86      * Mark all pages as unused (0xFFFF).
87      */
88     for (i = 0; i < minefield_npages; i++)
89         minefield_admin[i] = 0xFFFF;
90
91     /*
92      * Hide the admin region.
93      */
94     minefield_admin_hide(1);
95
96     minefield_initialised = 1;
97 }
98
99 static void minefield_bomb(void) {
100     div(1, *(int*)minefield_pages);
101 }
102
103 static void *minefield_alloc(int size) {
104     int npages;
105     int pos, lim, region_end, region_start;
106     int start;
107     int i;
108
109     npages = (size + PAGESIZE-1) / PAGESIZE;
110
111     minefield_admin_hide(0);
112
113     /*
114      * Search from current position until we find a contiguous
115      * bunch of npages+2 unused pages.
116      */
117     pos = minefield_curpos;
118     lim = minefield_npages;
119     while (1) {
120         /* Skip over used pages. */
121         while (pos < lim && minefield_admin[pos] != 0xFFFF)
122             pos++;
123         /* Count unused pages. */
124         start = pos;
125         while (pos < lim && pos - start < npages+2 &&
126                minefield_admin[pos] == 0xFFFF)
127             pos++;
128         if (pos - start == npages+2)
129             break;
130         /* If we've reached the limit, reset the limit or stop. */
131         if (pos >= lim) {
132             if (lim == minefield_npages) {
133                 /* go round and start again at zero */
134                 lim = minefield_curpos;
135                 pos = 0;
136             } else {
137                 minefield_admin_hide(1);
138                 return NULL;
139             }
140         }
141     }
142
143     minefield_curpos = pos-1;
144
145     /*
146      * We have npages+2 unused pages starting at start. We leave
147      * the first and last of these alone and use the rest.
148      */
149     region_end = (start + npages+1) * PAGESIZE;
150     region_start = region_end - size;
151     /* FIXME: could align here if we wanted */
152
153     /*
154      * Update the admin region.
155      */
156     for (i = start + 2; i < start + npages-1; i++)
157         minefield_admin[i] = 0xFFFE;   /* used but no region starts here */
158     minefield_admin[start+1] = region_start % PAGESIZE;
159
160     minefield_admin_hide(1);
161
162     VirtualAlloc((char *)minefield_pages + region_start, size,
163                  MEM_COMMIT, PAGE_READWRITE);
164     return (char *)minefield_pages + region_start;
165 }
166
167 static void minefield_free(void *ptr) {
168     int region_start, i, j;
169
170     minefield_admin_hide(0);
171
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)
176         minefield_bomb();
177     for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++) {
178         minefield_admin[j] = 0xFFFF;
179     }
180
181     VirtualFree(ptr, j*PAGESIZE - region_start, MEM_DECOMMIT);
182
183     minefield_admin_hide(1);
184 }
185
186 static int minefield_get_size(void *ptr) {
187     int region_start, i, j;
188
189     minefield_admin_hide(0);
190
191     region_start = (char *)ptr - (char *)minefield_pages;
192     i = region_start / PAGESIZE;
193     if (i < 0 || i >= minefield_npages ||
194         minefield_admin[i] != region_start % PAGESIZE)
195         minefield_bomb();
196     for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++);
197
198     minefield_admin_hide(1);
199
200     return j*PAGESIZE - region_start;
201 }
202
203 static void *minefield_c_malloc(size_t size) {
204     if (!minefield_initialised) minefield_init();
205     return minefield_alloc(size);
206 }
207
208 static void minefield_c_free(void *p) {
209     if (!minefield_initialised) minefield_init();
210     minefield_free(p);
211 }
212
213 /*
214  * realloc _always_ moves the chunk, for rapid detection of code
215  * that assumes it won't.
216  */
217 static void *minefield_c_realloc(void *p, size_t size) {
218     size_t oldsize;
219     void *q;
220     if (!minefield_initialised) minefield_init();
221     q = minefield_alloc(size);
222     oldsize = minefield_get_size(p);
223     memcpy(q, p, (oldsize < size ? oldsize : size));
224     minefield_free(p);
225     return q;
226 }
227
228 #endif /* MINEFIELD */
229
230 #ifdef MALLOC_LOG
231 static FILE *fp = NULL;
232
233 void mlog(char *file, int line) {
234     if (!fp) {
235         fp = fopen("putty_mem.log", "w");
236         setvbuf(fp, NULL, _IONBF, BUFSIZ);
237     }
238     if (fp)
239         fprintf (fp, "%s:%d: ", file, line);
240 }
241 #endif
242
243 void *safemalloc(size_t size) {
244     void *p;
245 #ifdef MINEFIELD
246     p = minefield_c_malloc (size);
247 #else
248     p = malloc (size);
249 #endif
250     if (!p) {
251         MessageBox(NULL, "Out of memory!", "PuTTY Fatal Error",
252                    MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
253         exit(1);
254     }
255 #ifdef MALLOC_LOG
256     if (fp)
257         fprintf(fp, "malloc(%d) returns %p\n", size, p);
258 #endif
259     return p;
260 }
261
262 void *saferealloc(void *ptr, size_t size) {
263     void *p;
264     if (!ptr) {
265 #ifdef MINEFIELD
266         p = minefield_c_malloc (size);
267 #else
268         p = malloc (size);
269 #endif
270     } else {
271 #ifdef MINEFIELD
272         p = minefield_c_realloc (ptr, size);
273 #else
274         p = realloc (ptr, size);
275 #endif
276     }
277     if (!p) {
278         MessageBox(NULL, "Out of memory!", "PuTTY Fatal Error",
279                    MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
280         exit(1);
281     }
282 #ifdef MALLOC_LOG
283     if (fp)
284         fprintf(fp, "realloc(%p,%d) returns %p\n", ptr, size, p);
285 #endif
286     return p;
287 }
288
289 void safefree(void *ptr) {
290     if (ptr) {
291 #ifdef MALLOC_LOG
292         if (fp)
293             fprintf(fp, "free(%p)\n", ptr);
294 #endif
295 #ifdef MINEFIELD
296         minefield_c_free (ptr);
297 #else
298         free (ptr);
299 #endif
300     }
301 #ifdef MALLOC_LOG
302     else if (fp)
303         fprintf(fp, "freeing null pointer - no action taken\n");
304 #endif
305 }
306
307 #ifdef DEBUG
308 static FILE *debug_fp = NULL;
309 static int debug_got_console = 0;
310
311 void dprintf(char *fmt, ...) {
312     char buf[2048];
313     DWORD dw;
314     va_list ap;
315
316     if (!debug_got_console) {
317         AllocConsole();
318         debug_got_console = 1;
319     }
320     if (!debug_fp) {
321         debug_fp = fopen("debug.log", "w");
322     }
323
324     va_start(ap, fmt);
325     vsprintf(buf, fmt, ap);
326     WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, strlen(buf), &dw, NULL);
327     fputs(buf, debug_fp);
328     fflush(debug_fp);
329     va_end(ap);
330 }
331 #endif