1 /* Wrappers around malloc and memory debugging support.
2 Copyright (C) 2003 Free Software Foundation, Inc.
4 This file is part of GNU Wget.
6 GNU Wget is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 GNU Wget is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with Wget; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 In addition, as a special exception, the Free Software Foundation
21 gives permission to link the code of its release of Wget with the
22 OpenSSL project's "OpenSSL" library (or with modified versions of it
23 that use the same license as the "OpenSSL" library), and distribute
24 the linked executables. You must obey the GNU General Public License
25 in all respects for all of the code used other than "OpenSSL". If you
26 modify this file, you may extend this exception to your version of the
27 file, but you are not obligated to do so. If you do not wish to do
28 so, delete this exception statement from your version. */
36 #else /* not HAVE_STRING_H */
38 #endif /* not HAVE_STRING_H */
39 #include <sys/types.h>
50 /* This file implements several wrappers around the basic allocation
51 routines. This is done for two reasons: first, so that the callers
52 of these functions need not check for errors, which is easy to
53 forget. If there is not enough virtual memory for running Wget,
54 something is seriously wrong, and Wget exits with an appropriate
57 The second reason why these are useful is that, if DEBUG_MALLOC is
58 defined, they also provide a handy (if crude) malloc debugging
59 interface that checks for memory leaks. */
61 /* Croak the fatal memory error and bail out with non-zero exit
65 memfatal (const char *context, long attempted_size)
67 /* Make sure we don't try to store part of the log line, and thus
69 log_set_save_context (0);
70 logprintf (LOG_ALWAYS,
71 _("%s: %s: Failed to allocate %ld bytes; memory exhausted.\n"),
72 exec_name, context, attempted_size);
76 /* These functions end with _real because they need to be
77 distinguished from the debugging functions, and from the macros.
80 If memory debugging is not turned on, xmalloc.h defines these:
82 #define xmalloc xmalloc_real
83 #define xmalloc0 xmalloc0_real
84 #define xrealloc xrealloc_real
85 #define xstrdup xstrdup_real
86 #define xfree xfree_real
88 In case of memory debugging, the definitions are a bit more
89 complex, because we want to provide more information, *and* we want
90 to call the debugging code. (The former is the reason why xmalloc
91 and friends need to be macros in the first place.) Then it looks
94 #define xmalloc(a) xmalloc_debug (a, __FILE__, __LINE__)
95 #define xmalloc0(a) xmalloc0_debug (a, __FILE__, __LINE__)
96 #define xrealloc(a, b) xrealloc_debug (a, b, __FILE__, __LINE__)
97 #define xstrdup(a) xstrdup_debug (a, __FILE__, __LINE__)
98 #define xfree(a) xfree_debug (a, __FILE__, __LINE__)
100 Each of the *_debug function does its magic and calls the real one. */
103 # define STATIC_IF_DEBUG static
105 # define STATIC_IF_DEBUG
108 STATIC_IF_DEBUG void *
109 xmalloc_real (size_t size)
111 void *ptr = malloc (size);
113 memfatal ("malloc", size);
117 STATIC_IF_DEBUG void *
118 xmalloc0_real (size_t size)
120 /* Using calloc can be faster than malloc+memset because some calloc
121 implementations know when they're dealing with zeroed-out memory
122 from the system and can avoid unnecessary memset. */
123 void *ptr = calloc (1, size);
125 memfatal ("calloc", size);
129 STATIC_IF_DEBUG void *
130 xrealloc_real (void *ptr, size_t newsize)
134 /* Not all Un*xes have the feature of realloc() that calling it with
135 a NULL-pointer is the same as malloc(), but it is easy to
138 newptr = realloc (ptr, newsize);
140 newptr = malloc (newsize);
142 memfatal ("realloc", newsize);
146 STATIC_IF_DEBUG char *
147 xstrdup_real (const char *s)
153 copy = malloc (l + 1);
155 memfatal ("strdup", l + 1);
156 memcpy (copy, s, l + 1);
157 #else /* HAVE_STRDUP */
160 memfatal ("strdup", 1 + strlen (s));
161 #endif /* HAVE_STRDUP */
167 xfree_real (void *ptr)
169 /* Wget's xfree() must not be passed a NULL pointer. This is for
170 historical reasons: many pre-C89 systems were known to bomb at
171 free(NULL), and Wget was careful to use xfree_null when there is
172 a possibility of PTR being NULL. (It might have been better to
173 simply have xfree() do nothing if ptr==NULL.)
175 Since the code is already written that way, this assert simply
176 enforces that constraint. Code that thinks it doesn't deal with
177 NULL, and it in fact does, aborts immediately. If you trip on
178 this, either the code has a pointer handling bug or should have
179 called xfree_null instead of xfree. Correctly written code
180 should never trigger this assertion.
182 If the assertion proves to be too much of a hassle, it can be
183 removed and a check that makes NULL a no-op placed in its stead.
184 If that is done, xfree_null is no longer needed and should be
186 assert (ptr != NULL);
190 /* xfree_real is unnecessary because free doesn't require any special
195 /* Crude home-grown routines for debugging some malloc-related
198 * Counting the number of malloc and free invocations, and reporting
199 the "balance", i.e. how many times more malloc was called than it
200 was the case with free.
202 * Making malloc store its entry into a simple array and free remove
203 stuff from that array. At the end, print the pointers which have
204 not been freed, along with the source file and the line number.
205 This also has the side-effect of detecting freeing memory that
208 Note that this kind of memory leak checking strongly depends on
209 every malloc() being followed by a free(), even if the program is
210 about to finish. Wget is careful to free the data structure it
211 allocated in init.c. */
213 static int malloc_count, free_count;
219 } malloc_debug[100000];
221 /* Both register_ptr and unregister_ptr take O(n) operations to run,
222 which can be a real problem. It would be nice to use a hash table
223 for malloc_debug, but the functions in hash.c are not suitable
224 because they can call malloc() themselves. Maybe it would work if
225 the hash table were preallocated to a huge size, and if we set the
226 rehash threshold to 1.0. */
228 /* Register PTR in malloc_debug. Abort if this is not possible
229 (presumably due to the number of current allocations exceeding the
230 size of malloc_debug.) */
233 register_ptr (void *ptr, const char *file, int line)
236 for (i = 0; i < countof (malloc_debug); i++)
237 if (malloc_debug[i].ptr == NULL)
239 malloc_debug[i].ptr = ptr;
240 malloc_debug[i].file = file;
241 malloc_debug[i].line = line;
247 /* Unregister PTR from malloc_debug. Abort if PTR is not present in
248 malloc_debug. (This catches calling free() with a bogus pointer.) */
251 unregister_ptr (void *ptr)
254 for (i = 0; i < countof (malloc_debug); i++)
255 if (malloc_debug[i].ptr == ptr)
257 malloc_debug[i].ptr = NULL;
263 /* Print the malloc debug stats that can be gathered from the above
264 information. Currently this is the count of mallocs, frees, the
265 difference between the two, and the dump of the contents of
266 malloc_debug. The last part are the memory leaks. */
269 print_malloc_debug_stats (void)
272 printf ("\nMalloc: %d\nFree: %d\nBalance: %d\n\n",
273 malloc_count, free_count, malloc_count - free_count);
274 for (i = 0; i < countof (malloc_debug); i++)
275 if (malloc_debug[i].ptr != NULL)
276 printf ("0x%08ld: %s:%d\n", (long)malloc_debug[i].ptr,
277 malloc_debug[i].file, malloc_debug[i].line);
281 xmalloc_debug (size_t size, const char *source_file, int source_line)
283 void *ptr = xmalloc_real (size);
285 register_ptr (ptr, source_file, source_line);
290 xmalloc0_debug (size_t size, const char *source_file, int source_line)
292 void *ptr = xmalloc0_real (size);
294 register_ptr (ptr, source_file, source_line);
299 xrealloc_debug (void *ptr, size_t newsize, const char *source_file, int source_line)
301 void *newptr = xrealloc_real (ptr, newsize);
305 register_ptr (newptr, source_file, source_line);
307 else if (newptr != ptr)
309 unregister_ptr (ptr);
310 register_ptr (newptr, source_file, source_line);
316 xstrdup_debug (const char *s, const char *source_file, int source_line)
318 char *copy = xstrdup_real (s);
320 register_ptr (copy, source_file, source_line);
325 xfree_debug (void *ptr, const char *source_file, int source_line)
327 /* See xfree_real for rationale of this abort. We repeat it here
328 because we can print the file and the line where the offending
332 fprintf ("%s: xfree(NULL) at %s:%d\n",
333 exec_name, source_file, source_line);
337 unregister_ptr (ptr);
341 #endif /* DEBUG_MALLOC */