2 Samba Unix SMB/CIFS implementation.
3 Samba temporary memory allocation functions
4 Copyright (C) Andrew Tridgell 2000
5 Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 @defgroup talloc Simple memory allocator
26 This is a very simple temporary memory allocator. To use it do the following:
28 1) when you first want to allocate a pool of meomry use
29 talloc_init() and save the resulting context pointer somewhere
31 2) to allocate memory use talloc()
33 3) when _all_ of the memory allocated using this context is no longer needed
36 talloc does not zero the memory. It guarantees memory of a
37 TALLOC_ALIGN alignment
43 * @todo We could allocate both the talloc_chunk structure, and the
44 * memory it contains all in one allocation, which might be a bit
45 * faster and perhaps use less memory overhead.
47 * That smells like a premature optimization, though. -- mbp
51 * If you want testing for memory corruption, link with dmalloc or use
52 * Insure++. It doesn't seem useful to duplicate them here.
58 struct talloc_chunk *next;
65 struct talloc_chunk *list;
66 size_t total_alloc_size;
68 /** The name recorded for this pool, if any. Should describe
69 * the purpose for which it was allocated. The string is
70 * allocated within the pool. **/
73 /** Pointer to the next allocate talloc pool, so that we can
74 * summarize all talloc memory usage. **/
75 struct talloc_ctx *next_ctx;
80 * Start of linked list of all talloc pools.
82 * @todo We should turn the global list off when using Insure++,
83 * otherwise all the memory will be seen as still reachable.
85 TALLOC_CTX *list_head = NULL;
89 * Add to the global list
91 static void talloc_enroll(TALLOC_CTX *t)
93 t->next_ctx = list_head;
98 static void talloc_disenroll(TALLOC_CTX *t)
102 /* Use a double-* so that no special case is required for the
104 for (ttmp = &list_head; *ttmp; ttmp = &((*ttmp)->next_ctx))
106 /* ttmp is the link that points to t, either
107 * list_head or the next_ctx link in its
110 t->next_ctx = NULL; /* clobber */
113 abort(); /* oops, this talloc was already
114 * clobbered or something else went
119 /** Create a new talloc context. **/
120 TALLOC_CTX *talloc_init(void)
124 t = (TALLOC_CTX *)malloc(sizeof(TALLOC_CTX));
127 t->total_alloc_size = 0;
138 * Create a new talloc context, with a name specifying its purpose.
139 * Please call this in preference to talloc_init().
141 TALLOC_CTX *talloc_init_named(char const *fmt, ...)
149 t->name = talloc_vasprintf(t, fmt, ap);
157 /** Allocate a bit of memory from the specified pool **/
158 void *talloc(TALLOC_CTX *t, size_t size)
161 struct talloc_chunk *tc;
163 if (!t || size == 0) return NULL;
167 tc = malloc(sizeof(*tc));
173 t->total_alloc_size += size;
182 /** A talloc version of realloc */
183 void *talloc_realloc(TALLOC_CTX *t, void *ptr, size_t size)
185 struct talloc_chunk *tc;
188 /* size zero is equivalent to free() */
192 /* realloc(NULL) is equavalent to malloc() */
194 return talloc(t, size);
196 for (tc=t->list; tc; tc=tc->next) {
197 if (tc->ptr == ptr) {
198 new_ptr = Realloc(ptr, size);
200 t->total_alloc_size += (size - tc->size);
210 /** Destroy all the memory allocated inside @p t, but not @p t
212 void talloc_destroy_pool(TALLOC_CTX *t)
214 struct talloc_chunk *c;
221 SAFE_FREE(t->list->ptr);
226 t->total_alloc_size = 0;
229 /** Destroy a whole pool including the context */
230 void talloc_destroy(TALLOC_CTX *t)
235 talloc_destroy_pool(t);
237 memset(t, 0, sizeof(TALLOC_CTX));
241 /** Return the current total size of the pool. */
242 size_t talloc_pool_size(TALLOC_CTX *t)
245 return t->total_alloc_size;
250 const char * talloc_pool_name(TALLOC_CTX const *t)
259 /** talloc and zero memory. */
260 void *talloc_zero(TALLOC_CTX *t, size_t size)
262 void *p = talloc(t, size);
265 memset(p, '\0', size);
270 /** memdup with a talloc. */
271 void *talloc_memdup(TALLOC_CTX *t, const void *p, size_t size)
273 void *newp = talloc(t,size);
276 memcpy(newp, p, size);
281 /** strdup with a talloc */
282 char *talloc_strdup(TALLOC_CTX *t, const char *p)
285 return talloc_memdup(t, p, strlen(p) + 1);
291 * Perform string formatting, and return a pointer to newly allocated
292 * memory holding the result, inside a memory pool.
294 char *talloc_asprintf(TALLOC_CTX *t, const char *fmt, ...)
300 ret = talloc_vasprintf(t, fmt, ap);
306 char *talloc_vasprintf(TALLOC_CTX *t, const char *fmt, va_list ap)
311 len = vsnprintf(NULL, 0, fmt, ap);
313 ret = talloc(t, len+1);
315 vsnprintf(ret, len+1, fmt, ap);
322 * Realloc @p s to append the formatted result of @p fmt and return @p
323 * s, which may have moved. Good for gradually accumulating output
324 * into a string buffer.
326 char *talloc_asprintf_append(TALLOC_CTX *t, char *s,
327 const char *fmt, ...)
332 s = talloc_vasprintf_append(t, s, fmt, ap);
340 * Realloc @p s to append the formatted result of @p fmt and @p ap,
341 * and return @p s, which may have moved. Good for gradually
342 * accumulating output into a string buffer.
344 char *talloc_vasprintf_append(TALLOC_CTX *t, char *s,
345 const char *fmt, va_list ap)
350 len = vsnprintf(NULL, 0, fmt, ap);
352 s = talloc_realloc(t, s, s_len + len+1);
355 vsnprintf(s+s_len, len+1, fmt, ap);
362 * Return a human-readable description of all talloc memory usage.
363 * The result is allocated from @p t.
365 char *talloc_describe_all(TALLOC_CTX *rt)
367 int n_pools = 0, total_chunks = 0;
368 size_t total_bytes = 0;
372 if (!rt) return NULL;
374 s = talloc_asprintf(rt, "global talloc allocations in pid: %u\n",
375 (unsigned) sys_getpid());
376 s = talloc_asprintf_append(rt, s, "%-40s %8s %8s\n",
377 "name", "chunks", "bytes");
378 s = talloc_asprintf_append(rt, s, "%-40s %8s %8s\n",
379 "----------------------------------------",
383 for (it = list_head; it; it = it->next_ctx) {
390 talloc_get_allocation(it, &bytes, &n_chunks);
393 fstrcpy(what, it->name);
395 slprintf(what, sizeof what, "@%p", it);
397 s = talloc_asprintf_append(rt, s, "%-40s %8u %8u\n",
401 total_bytes += bytes;
402 total_chunks += n_chunks;
405 s = talloc_asprintf_append(rt, s, "%-40s %8s %8s\n",
406 "----------------------------------------",
410 s = talloc_asprintf_append(rt, s, "%-40s %8u %8u\n",
412 (unsigned) total_chunks, (unsigned) total_bytes);
420 * Return an estimated memory usage for the specified pool. This does
421 * not include memory used by the underlying malloc implementation.
423 void talloc_get_allocation(TALLOC_CTX *t,
427 struct talloc_chunk *chunk;
433 for (chunk = t->list; chunk; chunk = chunk->next) {
435 *total_bytes += chunk->size;