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 static 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 static TALLOC_CTX
*talloc_init_internal(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.
141 TALLOC_CTX
*talloc_init(char const *fmt
, ...)
146 t
= talloc_init_internal();
149 * t->name must not be talloced.
150 * as destroying the pool would destroy it. JRA.
154 vasprintf(&t
->name
, fmt
, ap
);
166 /** Allocate a bit of memory from the specified pool **/
167 void *talloc(TALLOC_CTX
*t
, size_t size
)
170 struct talloc_chunk
*tc
;
172 if (!t
|| size
== 0) return NULL
;
176 tc
= malloc(sizeof(*tc
));
182 t
->total_alloc_size
+= size
;
191 /** A talloc version of realloc */
192 void *talloc_realloc(TALLOC_CTX
*t
, void *ptr
, size_t size
)
194 struct talloc_chunk
*tc
;
197 /* size zero is equivalent to free() */
201 /* realloc(NULL) is equavalent to malloc() */
203 return talloc(t
, size
);
205 for (tc
=t
->list
; tc
; tc
=tc
->next
) {
206 if (tc
->ptr
== ptr
) {
207 new_ptr
= Realloc(ptr
, size
);
209 t
->total_alloc_size
+= (size
- tc
->size
);
219 /** Destroy all the memory allocated inside @p t, but not @p t
221 void talloc_destroy_pool(TALLOC_CTX
*t
)
223 struct talloc_chunk
*c
;
230 SAFE_FREE(t
->list
->ptr
);
235 t
->total_alloc_size
= 0;
238 /** Destroy a whole pool including the context */
239 void talloc_destroy(TALLOC_CTX
*t
)
244 talloc_destroy_pool(t
);
247 memset(t
, 0, sizeof(TALLOC_CTX
));
251 /** Return the current total size of the pool. */
252 size_t talloc_pool_size(TALLOC_CTX
*t
)
255 return t
->total_alloc_size
;
260 const char * talloc_pool_name(TALLOC_CTX
const *t
)
269 /** talloc and zero memory. */
270 void *talloc_zero(TALLOC_CTX
*t
, size_t size
)
272 void *p
= talloc(t
, size
);
275 memset(p
, '\0', size
);
280 /** memdup with a talloc. */
281 void *talloc_memdup(TALLOC_CTX
*t
, const void *p
, size_t size
)
283 void *newp
= talloc(t
,size
);
286 memcpy(newp
, p
, size
);
291 /** strdup with a talloc */
292 char *talloc_strdup(TALLOC_CTX
*t
, const char *p
)
295 return talloc_memdup(t
, p
, strlen(p
) + 1);
300 /** strdup_w with a talloc */
301 smb_ucs2_t
*talloc_strdup_w(TALLOC_CTX
*t
, const smb_ucs2_t
*p
)
304 return talloc_memdup(t
, p
, (strlen_w(p
) + 1) * sizeof(smb_ucs2_t
));
310 * Perform string formatting, and return a pointer to newly allocated
311 * memory holding the result, inside a memory pool.
313 char *talloc_asprintf(TALLOC_CTX
*t
, const char *fmt
, ...)
319 ret
= talloc_vasprintf(t
, fmt
, ap
);
325 char *talloc_vasprintf(TALLOC_CTX
*t
, const char *fmt
, va_list ap
)
333 len
= vsnprintf(NULL
, 0, fmt
, ap2
);
335 ret
= talloc(t
, len
+1);
338 vsnprintf(ret
, len
+1, fmt
, ap2
);
346 * Realloc @p s to append the formatted result of @p fmt and return @p
347 * s, which may have moved. Good for gradually accumulating output
348 * into a string buffer.
350 char *talloc_asprintf_append(TALLOC_CTX
*t
, char *s
,
351 const char *fmt
, ...)
356 s
= talloc_vasprintf_append(t
, s
, fmt
, ap
);
364 * Realloc @p s to append the formatted result of @p fmt and @p ap,
365 * and return @p s, which may have moved. Good for gradually
366 * accumulating output into a string buffer.
368 char *talloc_vasprintf_append(TALLOC_CTX
*t
, char *s
,
369 const char *fmt
, va_list ap
)
377 len
= vsnprintf(NULL
, 0, fmt
, ap2
);
379 s
= talloc_realloc(t
, s
, s_len
+ len
+1);
384 vsnprintf(s
+s_len
, len
+1, fmt
, ap2
);
391 * Return a human-readable description of all talloc memory usage.
392 * The result is allocated from @p t.
394 char *talloc_describe_all(TALLOC_CTX
*rt
)
396 int n_pools
= 0, total_chunks
= 0;
397 size_t total_bytes
= 0;
401 if (!rt
) return NULL
;
403 s
= talloc_asprintf(rt
, "global talloc allocations in pid: %u\n",
404 (unsigned) sys_getpid());
405 s
= talloc_asprintf_append(rt
, s
, "%-40s %8s %8s\n",
406 "name", "chunks", "bytes");
407 s
= talloc_asprintf_append(rt
, s
, "%-40s %8s %8s\n",
408 "----------------------------------------",
412 for (it
= list_head
; it
; it
= it
->next_ctx
) {
419 talloc_get_allocation(it
, &bytes
, &n_chunks
);
422 fstrcpy(what
, it
->name
);
424 slprintf(what
, sizeof(what
), "@%p", it
);
426 s
= talloc_asprintf_append(rt
, s
, "%-40s %8u %8u\n",
430 total_bytes
+= bytes
;
431 total_chunks
+= n_chunks
;
434 s
= talloc_asprintf_append(rt
, s
, "%-40s %8s %8s\n",
435 "----------------------------------------",
439 s
= talloc_asprintf_append(rt
, s
, "%-40s %8u %8u\n",
441 (unsigned) total_chunks
, (unsigned) total_bytes
);
449 * Return an estimated memory usage for the specified pool. This does
450 * not include memory used by the underlying malloc implementation.
452 void talloc_get_allocation(TALLOC_CTX
*t
,
456 struct talloc_chunk
*chunk
;
462 for (chunk
= t
->list
; chunk
; chunk
= chunk
->next
) {
464 *total_bytes
+= chunk
->size
;