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 */