2 Samba Unix SMB/CIFS implementation.
4 Samba trivial allocation library - new interface
6 NOTE: Please read talloc_guide.txt for full documentation
8 Copyright (C) Andrew Tridgell 2004
9 Copyright (C) Stefan Metzmacher 2006
11 ** NOTE! The following LGPL license applies to the talloc
12 ** library. This does NOT imply that all of Samba is released
15 This library is free software; you can redistribute it and/or
16 modify it under the terms of the GNU Lesser General Public
17 License as published by the Free Software Foundation; either
18 version 3 of the License, or (at your option) any later version.
20 This library is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 Lesser General Public License for more details.
25 You should have received a copy of the GNU Lesser General Public
26 License along with this library; if not, see <http://www.gnu.org/licenses/>.
30 inspired by http://swapped.cc/halloc/
36 #ifdef TALLOC_BUILD_VERSION_MAJOR
37 #if (TALLOC_VERSION_MAJOR != TALLOC_BUILD_VERSION_MAJOR)
38 #error "TALLOC_VERSION_MAJOR != TALLOC_BUILD_VERSION_MAJOR"
42 #ifdef TALLOC_BUILD_VERSION_MINOR
43 #if (TALLOC_VERSION_MINOR != TALLOC_BUILD_VERSION_MINOR)
44 #error "TALLOC_VERSION_MINOR != TALLOC_BUILD_VERSION_MINOR"
48 /* Special macros that are no-ops except when run under Valgrind on
49 * x86. They've moved a little bit from valgrind 1.0.4 to 1.9.4 */
50 #ifdef HAVE_VALGRIND_MEMCHECK_H
51 /* memcheck.h includes valgrind.h */
52 #include <valgrind/memcheck.h>
53 #elif defined(HAVE_VALGRIND_H)
57 /* use this to force every realloc to change the pointer, to stress test
58 code that might not cope */
59 #define ALWAYS_REALLOC 0
62 #define MAX_TALLOC_SIZE 0x10000000
63 #define TALLOC_MAGIC_BASE 0xe814ec70
64 #define TALLOC_MAGIC ( \
66 (TALLOC_VERSION_MAJOR << 12) + \
67 (TALLOC_VERSION_MINOR << 4) \
70 #define TALLOC_FLAG_FREE 0x01
71 #define TALLOC_FLAG_LOOP 0x02
72 #define TALLOC_FLAG_POOL 0x04 /* This is a talloc pool */
73 #define TALLOC_FLAG_POOLMEM 0x08 /* This is allocated in a pool */
74 #define TALLOC_MAGIC_REFERENCE ((const char *)1)
76 /* by default we abort when given a bad pointer (such as when talloc_free() is called
77 on a pointer that came from malloc() */
79 #define TALLOC_ABORT(reason) abort()
82 #ifndef discard_const_p
83 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
84 # define discard_const_p(type, ptr) ((type *)((intptr_t)(ptr)))
86 # define discard_const_p(type, ptr) ((type *)(ptr))
90 /* these macros gain us a few percent of speed on gcc */
92 /* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
93 as its first argument */
95 #define likely(x) __builtin_expect(!!(x), 1)
98 #define unlikely(x) __builtin_expect(!!(x), 0)
102 #define likely(x) (x)
105 #define unlikely(x) (x)
109 /* this null_context is only used if talloc_enable_leak_report() or
110 talloc_enable_leak_report_full() is called, otherwise it remains
113 static void *null_context
;
114 static void *autofree_context
;
116 /* used to enable fill of memory on free, which can be useful for
117 * catching use after free errors when valgrind is too slow
125 #define TALLOC_FILL_ENV "TALLOC_FREE_FILL"
128 * do not wipe the header, to allow the
129 * double-free logic to still work
131 #define TC_INVALIDATE_FULL_FILL_CHUNK(_tc) do { \
132 if (unlikely(talloc_fill.enabled)) { \
133 size_t _flen = (_tc)->size; \
134 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
135 memset(_fptr, talloc_fill.fill_value, _flen); \
139 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
140 /* Mark the whole chunk as not accessable */
141 #define TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc) do { \
142 size_t _flen = TC_HDR_SIZE + (_tc)->size; \
143 char *_fptr = (char *)(_tc); \
144 VALGRIND_MAKE_MEM_NOACCESS(_fptr, _flen); \
147 #define TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc) do { } while (0)
150 #define TC_INVALIDATE_FULL_CHUNK(_tc) do { \
151 TC_INVALIDATE_FULL_FILL_CHUNK(_tc); \
152 TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc); \
155 #define TC_INVALIDATE_SHRINK_FILL_CHUNK(_tc, _new_size) do { \
156 if (unlikely(talloc_fill.enabled)) { \
157 size_t _flen = (_tc)->size - (_new_size); \
158 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
159 _fptr += (_new_size); \
160 memset(_fptr, talloc_fill.fill_value, _flen); \
164 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
165 /* Mark the unused bytes not accessable */
166 #define TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { \
167 size_t _flen = (_tc)->size - (_new_size); \
168 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
169 _fptr += (_new_size); \
170 VALGRIND_MAKE_MEM_NOACCESS(_fptr, _flen); \
173 #define TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
176 #define TC_INVALIDATE_SHRINK_CHUNK(_tc, _new_size) do { \
177 TC_INVALIDATE_SHRINK_FILL_CHUNK(_tc, _new_size); \
178 TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size); \
181 #define TC_UNDEFINE_SHRINK_FILL_CHUNK(_tc, _new_size) do { \
182 if (unlikely(talloc_fill.enabled)) { \
183 size_t _flen = (_tc)->size - (_new_size); \
184 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
185 _fptr += (_new_size); \
186 memset(_fptr, talloc_fill.fill_value, _flen); \
190 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
191 /* Mark the unused bytes as undefined */
192 #define TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { \
193 size_t _flen = (_tc)->size - (_new_size); \
194 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
195 _fptr += (_new_size); \
196 VALGRIND_MAKE_MEM_UNDEFINED(_fptr, _flen); \
199 #define TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
202 #define TC_UNDEFINE_SHRINK_CHUNK(_tc, _new_size) do { \
203 TC_UNDEFINE_SHRINK_FILL_CHUNK(_tc, _new_size); \
204 TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size); \
207 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
208 /* Mark the new bytes as undefined */
209 #define TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size) do { \
210 size_t _old_used = TC_HDR_SIZE + (_tc)->size; \
211 size_t _new_used = TC_HDR_SIZE + (_new_size); \
212 size_t _flen = _new_used - _old_used; \
213 char *_fptr = _old_used + (char *)(_tc); \
214 VALGRIND_MAKE_MEM_UNDEFINED(_fptr, _flen); \
217 #define TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
220 #define TC_UNDEFINE_GROW_CHUNK(_tc, _new_size) do { \
221 TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size); \
224 struct talloc_reference_handle
{
225 struct talloc_reference_handle
*next
, *prev
;
227 const char *location
;
230 typedef int (*talloc_destructor_t
)(void *);
232 struct talloc_chunk
{
233 struct talloc_chunk
*next
, *prev
;
234 struct talloc_chunk
*parent
, *child
;
235 struct talloc_reference_handle
*refs
;
236 talloc_destructor_t destructor
;
242 * "pool" has dual use:
244 * For the talloc pool itself (i.e. TALLOC_FLAG_POOL is set), "pool"
245 * marks the end of the currently allocated area.
247 * For members of the pool (i.e. TALLOC_FLAG_POOLMEM is set), "pool"
248 * is a pointer to the struct talloc_chunk of the pool that it was
249 * allocated from. This way children can quickly find the pool to chew
255 /* 16 byte alignment seems to keep everyone happy */
256 #define TC_ALIGN16(s) (((s)+15)&~15)
257 #define TC_HDR_SIZE TC_ALIGN16(sizeof(struct talloc_chunk))
258 #define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
260 _PUBLIC_
int talloc_version_major(void)
262 return TALLOC_VERSION_MAJOR
;
265 _PUBLIC_
int talloc_version_minor(void)
267 return TALLOC_VERSION_MINOR
;
270 static void (*talloc_log_fn
)(const char *message
);
272 _PUBLIC_
void talloc_set_log_fn(void (*log_fn
)(const char *message
))
274 talloc_log_fn
= log_fn
;
277 static void talloc_log(const char *fmt
, ...) PRINTF_ATTRIBUTE(1,2);
278 static void talloc_log(const char *fmt
, ...)
283 if (!talloc_log_fn
) {
288 message
= talloc_vasprintf(NULL
, fmt
, ap
);
291 talloc_log_fn(message
);
292 talloc_free(message
);
295 static void talloc_log_stderr(const char *message
)
297 fprintf(stderr
, "%s", message
);
300 _PUBLIC_
void talloc_set_log_stderr(void)
302 talloc_set_log_fn(talloc_log_stderr
);
305 static void (*talloc_abort_fn
)(const char *reason
);
307 _PUBLIC_
void talloc_set_abort_fn(void (*abort_fn
)(const char *reason
))
309 talloc_abort_fn
= abort_fn
;
312 static void talloc_abort(const char *reason
)
314 talloc_log("%s\n", reason
);
316 if (!talloc_abort_fn
) {
317 TALLOC_ABORT(reason
);
320 talloc_abort_fn(reason
);
323 static void talloc_abort_magic(unsigned magic
)
325 unsigned striped
= magic
- TALLOC_MAGIC_BASE
;
326 unsigned major
= (striped
& 0xFFFFF000) >> 12;
327 unsigned minor
= (striped
& 0x00000FF0) >> 4;
328 talloc_log("Bad talloc magic[0x%08X/%u/%u] expected[0x%08X/%u/%u]\n",
330 TALLOC_MAGIC
, TALLOC_VERSION_MAJOR
, TALLOC_VERSION_MINOR
);
331 talloc_abort("Bad talloc magic value - wrong talloc version used/mixed");
334 static void talloc_abort_access_after_free(void)
336 talloc_abort("Bad talloc magic value - access after free");
339 static void talloc_abort_unknown_value(void)
341 talloc_abort("Bad talloc magic value - unknown value");
344 /* panic if we get a bad magic value */
345 static inline struct talloc_chunk
*talloc_chunk_from_ptr(const void *ptr
)
347 const char *pp
= (const char *)ptr
;
348 struct talloc_chunk
*tc
= discard_const_p(struct talloc_chunk
, pp
- TC_HDR_SIZE
);
349 if (unlikely((tc
->flags
& (TALLOC_FLAG_FREE
| ~0xF)) != TALLOC_MAGIC
)) {
350 if ((tc
->flags
& (~0xFFF)) == TALLOC_MAGIC_BASE
) {
351 talloc_abort_magic(tc
->flags
& (~0xF));
355 if (tc
->flags
& TALLOC_FLAG_FREE
) {
356 talloc_log("talloc: access after free error - first free may be at %s\n", tc
->name
);
357 talloc_abort_access_after_free();
360 talloc_abort_unknown_value();
367 /* hook into the front of the list */
368 #define _TLIST_ADD(list, p) \
372 (p)->next = (p)->prev = NULL; \
374 (list)->prev = (p); \
375 (p)->next = (list); \
381 /* remove an element from a list - element doesn't have to be in list. */
382 #define _TLIST_REMOVE(list, p) \
384 if ((p) == (list)) { \
385 (list) = (p)->next; \
386 if (list) (list)->prev = NULL; \
388 if ((p)->prev) (p)->prev->next = (p)->next; \
389 if ((p)->next) (p)->next->prev = (p)->prev; \
391 if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \
396 return the parent chunk of a pointer
398 static inline struct talloc_chunk
*talloc_parent_chunk(const void *ptr
)
400 struct talloc_chunk
*tc
;
402 if (unlikely(ptr
== NULL
)) {
406 tc
= talloc_chunk_from_ptr(ptr
);
407 while (tc
->prev
) tc
=tc
->prev
;
412 _PUBLIC_
void *talloc_parent(const void *ptr
)
414 struct talloc_chunk
*tc
= talloc_parent_chunk(ptr
);
415 return tc
? TC_PTR_FROM_CHUNK(tc
) : NULL
;
421 _PUBLIC_
const char *talloc_parent_name(const void *ptr
)
423 struct talloc_chunk
*tc
= talloc_parent_chunk(ptr
);
424 return tc
? tc
->name
: NULL
;
428 A pool carries an in-pool object count count in the first 16 bytes.
429 bytes. This is done to support talloc_steal() to a parent outside of the
430 pool. The count includes the pool itself, so a talloc_free() on a pool will
431 only destroy the pool if the count has dropped to zero. A talloc_free() of a
432 pool member will reduce the count, and eventually also call free(3) on the
435 The object count is not put into "struct talloc_chunk" because it is only
436 relevant for talloc pools and the alignment to 16 bytes would increase the
437 memory footprint of each talloc chunk by those 16 bytes.
440 #define TALLOC_POOL_HDR_SIZE 16
442 #define TC_POOL_SPACE_LEFT(_pool_tc) \
443 PTR_DIFF(TC_HDR_SIZE + (_pool_tc)->size + (char *)(_pool_tc), \
446 #define TC_POOL_FIRST_CHUNK(_pool_tc) \
447 ((void *)(TC_HDR_SIZE + TALLOC_POOL_HDR_SIZE + (char *)(_pool_tc)))
449 #define TC_POOLMEM_CHUNK_SIZE(_tc) \
450 TC_ALIGN16(TC_HDR_SIZE + (_tc)->size)
452 #define TC_POOLMEM_NEXT_CHUNK(_tc) \
453 ((void *)(TC_POOLMEM_CHUNK_SIZE(tc) + (char*)(_tc)))
455 /* Mark the whole remaining pool as not accessable */
456 #define TC_INVALIDATE_FILL_POOL(_pool_tc) do { \
457 if (unlikely(talloc_fill.enabled)) { \
458 size_t _flen = TC_POOL_SPACE_LEFT(_pool_tc); \
459 char *_fptr = (char *)(_pool_tc)->pool; \
460 memset(_fptr, talloc_fill.fill_value, _flen); \
464 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
465 /* Mark the whole remaining pool as not accessable */
466 #define TC_INVALIDATE_VALGRIND_POOL(_pool_tc) do { \
467 size_t _flen = TC_POOL_SPACE_LEFT(_pool_tc); \
468 char *_fptr = (char *)(_pool_tc)->pool; \
469 VALGRIND_MAKE_MEM_NOACCESS(_fptr, _flen); \
472 #define TC_INVALIDATE_VALGRIND_POOL(_pool_tc) do { } while (0)
475 #define TC_INVALIDATE_POOL(_pool_tc) do { \
476 TC_INVALIDATE_FILL_POOL(_pool_tc); \
477 TC_INVALIDATE_VALGRIND_POOL(_pool_tc); \
480 static unsigned int *talloc_pool_objectcount(struct talloc_chunk
*tc
)
482 return (unsigned int *)((char *)tc
+ TC_HDR_SIZE
);
489 static struct talloc_chunk
*talloc_alloc_pool(struct talloc_chunk
*parent
,
492 struct talloc_chunk
*pool_ctx
= NULL
;
494 struct talloc_chunk
*result
;
497 if (parent
== NULL
) {
501 if (parent
->flags
& TALLOC_FLAG_POOL
) {
504 else if (parent
->flags
& TALLOC_FLAG_POOLMEM
) {
505 pool_ctx
= (struct talloc_chunk
*)parent
->pool
;
508 if (pool_ctx
== NULL
) {
512 space_left
= TC_POOL_SPACE_LEFT(pool_ctx
);
515 * Align size to 16 bytes
517 chunk_size
= TC_ALIGN16(size
);
519 if (space_left
< chunk_size
) {
523 result
= (struct talloc_chunk
*)pool_ctx
->pool
;
525 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
526 VALGRIND_MAKE_MEM_UNDEFINED(result
, size
);
529 pool_ctx
->pool
= (void *)((char *)result
+ chunk_size
);
531 result
->flags
= TALLOC_MAGIC
| TALLOC_FLAG_POOLMEM
;
532 result
->pool
= pool_ctx
;
534 *talloc_pool_objectcount(pool_ctx
) += 1;
540 Allocate a bit of memory as a child of an existing pointer
542 static inline void *__talloc(const void *context
, size_t size
)
544 struct talloc_chunk
*tc
= NULL
;
546 if (unlikely(context
== NULL
)) {
547 context
= null_context
;
550 if (unlikely(size
>= MAX_TALLOC_SIZE
)) {
554 if (context
!= NULL
) {
555 tc
= talloc_alloc_pool(talloc_chunk_from_ptr(context
),
560 tc
= (struct talloc_chunk
*)malloc(TC_HDR_SIZE
+size
);
561 if (unlikely(tc
== NULL
)) return NULL
;
562 tc
->flags
= TALLOC_MAGIC
;
567 tc
->destructor
= NULL
;
572 if (likely(context
)) {
573 struct talloc_chunk
*parent
= talloc_chunk_from_ptr(context
);
576 parent
->child
->parent
= NULL
;
577 tc
->next
= parent
->child
;
586 tc
->next
= tc
->prev
= tc
->parent
= NULL
;
589 return TC_PTR_FROM_CHUNK(tc
);
593 * Create a talloc pool
596 _PUBLIC_
void *talloc_pool(const void *context
, size_t size
)
598 void *result
= __talloc(context
, size
+ TALLOC_POOL_HDR_SIZE
);
599 struct talloc_chunk
*tc
;
601 if (unlikely(result
== NULL
)) {
605 tc
= talloc_chunk_from_ptr(result
);
607 tc
->flags
|= TALLOC_FLAG_POOL
;
608 tc
->pool
= TC_POOL_FIRST_CHUNK(tc
);
610 *talloc_pool_objectcount(tc
) = 1;
612 TC_INVALIDATE_POOL(tc
);
618 setup a destructor to be called on free of a pointer
619 the destructor should return 0 on success, or -1 on failure.
620 if the destructor fails then the free is failed, and the memory can
621 be continued to be used
623 _PUBLIC_
void _talloc_set_destructor(const void *ptr
, int (*destructor
)(void *))
625 struct talloc_chunk
*tc
= talloc_chunk_from_ptr(ptr
);
626 tc
->destructor
= destructor
;
630 increase the reference count on a piece of memory.
632 _PUBLIC_
int talloc_increase_ref_count(const void *ptr
)
634 if (unlikely(!talloc_reference(null_context
, ptr
))) {
641 helper for talloc_reference()
643 this is referenced by a function pointer and should not be inline
645 static int talloc_reference_destructor(struct talloc_reference_handle
*handle
)
647 struct talloc_chunk
*ptr_tc
= talloc_chunk_from_ptr(handle
->ptr
);
648 _TLIST_REMOVE(ptr_tc
->refs
, handle
);
653 more efficient way to add a name to a pointer - the name must point to a
656 static inline void _talloc_set_name_const(const void *ptr
, const char *name
)
658 struct talloc_chunk
*tc
= talloc_chunk_from_ptr(ptr
);
663 internal talloc_named_const()
665 static inline void *_talloc_named_const(const void *context
, size_t size
, const char *name
)
669 ptr
= __talloc(context
, size
);
670 if (unlikely(ptr
== NULL
)) {
674 _talloc_set_name_const(ptr
, name
);
680 make a secondary reference to a pointer, hanging off the given context.
681 the pointer remains valid until both the original caller and this given
684 the major use for this is when two different structures need to reference the
685 same underlying data, and you want to be able to free the two instances separately,
688 _PUBLIC_
void *_talloc_reference_loc(const void *context
, const void *ptr
, const char *location
)
690 struct talloc_chunk
*tc
;
691 struct talloc_reference_handle
*handle
;
692 if (unlikely(ptr
== NULL
)) return NULL
;
694 tc
= talloc_chunk_from_ptr(ptr
);
695 handle
= (struct talloc_reference_handle
*)_talloc_named_const(context
,
696 sizeof(struct talloc_reference_handle
),
697 TALLOC_MAGIC_REFERENCE
);
698 if (unlikely(handle
== NULL
)) return NULL
;
700 /* note that we hang the destructor off the handle, not the
701 main context as that allows the caller to still setup their
702 own destructor on the context if they want to */
703 talloc_set_destructor(handle
, talloc_reference_destructor
);
704 handle
->ptr
= discard_const_p(void, ptr
);
705 handle
->location
= location
;
706 _TLIST_ADD(tc
->refs
, handle
);
710 static void *_talloc_steal_internal(const void *new_ctx
, const void *ptr
);
712 static inline void _talloc_free_poolmem(struct talloc_chunk
*tc
,
713 const char *location
)
715 struct talloc_chunk
*pool
;
717 unsigned int *pool_object_count
;
719 pool
= (struct talloc_chunk
*)tc
->pool
;
720 next_tc
= TC_POOLMEM_NEXT_CHUNK(tc
);
722 tc
->flags
|= TALLOC_FLAG_FREE
;
724 /* we mark the freed memory with where we called the free
725 * from. This means on a double free error we can report where
726 * the first free came from
730 TC_INVALIDATE_FULL_CHUNK(tc
);
732 pool_object_count
= talloc_pool_objectcount(pool
);
734 if (unlikely(*pool_object_count
== 0)) {
735 talloc_abort("Pool object count zero!");
739 *pool_object_count
-= 1;
741 if (unlikely(*pool_object_count
== 1 && !(pool
->flags
& TALLOC_FLAG_FREE
))) {
743 * if there is just one object left in the pool
744 * and pool->flags does not have TALLOC_FLAG_FREE,
745 * it means this is the pool itself and
746 * the rest is available for new objects
749 pool
->pool
= TC_POOL_FIRST_CHUNK(pool
);
750 TC_INVALIDATE_POOL(pool
);
751 } else if (unlikely(*pool_object_count
== 0)) {
753 * we mark the freed memory with where we called the free
754 * from. This means on a double free error we can report where
755 * the first free came from
757 pool
->name
= location
;
759 TC_INVALIDATE_FULL_CHUNK(pool
);
761 } else if (pool
->pool
== next_tc
) {
763 * if pool->pool still points to end of
764 * 'tc' (which is stored in the 'next_tc' variable),
765 * we can reclaim the memory of 'tc'.
772 internal talloc_free call
774 static inline int _talloc_free_internal(void *ptr
, const char *location
)
776 struct talloc_chunk
*tc
;
778 if (unlikely(ptr
== NULL
)) {
782 /* possibly initialised the talloc fill value */
783 if (unlikely(!talloc_fill
.initialised
)) {
784 const char *fill
= getenv(TALLOC_FILL_ENV
);
786 talloc_fill
.enabled
= true;
787 talloc_fill
.fill_value
= strtoul(fill
, NULL
, 0);
789 talloc_fill
.initialised
= true;
792 tc
= talloc_chunk_from_ptr(ptr
);
794 if (unlikely(tc
->refs
)) {
796 /* check if this is a reference from a child or
797 * grandchild back to it's parent or grandparent
799 * in that case we need to remove the reference and
800 * call another instance of talloc_free() on the current
803 is_child
= talloc_is_parent(tc
->refs
, ptr
);
804 _talloc_free_internal(tc
->refs
, location
);
806 return _talloc_free_internal(ptr
, location
);
811 if (unlikely(tc
->flags
& TALLOC_FLAG_LOOP
)) {
812 /* we have a free loop - stop looping */
816 if (unlikely(tc
->destructor
)) {
817 talloc_destructor_t d
= tc
->destructor
;
818 if (d
== (talloc_destructor_t
)-1) {
821 tc
->destructor
= (talloc_destructor_t
)-1;
826 tc
->destructor
= NULL
;
830 _TLIST_REMOVE(tc
->parent
->child
, tc
);
831 if (tc
->parent
->child
) {
832 tc
->parent
->child
->parent
= tc
->parent
;
835 if (tc
->prev
) tc
->prev
->next
= tc
->next
;
836 if (tc
->next
) tc
->next
->prev
= tc
->prev
;
839 tc
->flags
|= TALLOC_FLAG_LOOP
;
842 /* we need to work out who will own an abandoned child
843 if it cannot be freed. In priority order, the first
844 choice is owner of any remaining reference to this
845 pointer, the second choice is our parent, and the
846 final choice is the null context. */
847 void *child
= TC_PTR_FROM_CHUNK(tc
->child
);
848 const void *new_parent
= null_context
;
849 struct talloc_chunk
*old_parent
= NULL
;
850 if (unlikely(tc
->child
->refs
)) {
851 struct talloc_chunk
*p
= talloc_parent_chunk(tc
->child
->refs
);
852 if (p
) new_parent
= TC_PTR_FROM_CHUNK(p
);
854 /* finding the parent here is potentially quite
855 expensive, but the alternative, which is to change
856 talloc to always have a valid tc->parent pointer,
857 makes realloc more expensive where there are a
858 large number of children.
860 The reason we need the parent pointer here is that
861 if _talloc_free_internal() fails due to references
862 or a failing destructor we need to re-parent, but
863 the free call can invalidate the prev pointer.
865 if (new_parent
== null_context
&& (tc
->child
->refs
|| tc
->child
->destructor
)) {
866 old_parent
= talloc_parent_chunk(ptr
);
868 if (unlikely(_talloc_free_internal(child
, location
) == -1)) {
869 if (new_parent
== null_context
) {
870 struct talloc_chunk
*p
= old_parent
;
871 if (p
) new_parent
= TC_PTR_FROM_CHUNK(p
);
873 _talloc_steal_internal(new_parent
, child
);
877 tc
->flags
|= TALLOC_FLAG_FREE
;
879 /* we mark the freed memory with where we called the free
880 * from. This means on a double free error we can report where
881 * the first free came from
885 if (tc
->flags
& TALLOC_FLAG_POOL
) {
886 unsigned int *pool_object_count
;
888 pool_object_count
= talloc_pool_objectcount(tc
);
890 if (unlikely(*pool_object_count
== 0)) {
891 talloc_abort("Pool object count zero!");
895 *pool_object_count
-= 1;
897 if (unlikely(*pool_object_count
== 0)) {
898 TC_INVALIDATE_FULL_CHUNK(tc
);
901 } else if (tc
->flags
& TALLOC_FLAG_POOLMEM
) {
902 _talloc_free_poolmem(tc
, location
);
904 TC_INVALIDATE_FULL_CHUNK(tc
);
911 move a lump of memory from one talloc context to another return the
912 ptr on success, or NULL if it could not be transferred.
913 passing NULL as ptr will always return NULL with no side effects.
915 static void *_talloc_steal_internal(const void *new_ctx
, const void *ptr
)
917 struct talloc_chunk
*tc
, *new_tc
;
919 if (unlikely(!ptr
)) {
923 if (unlikely(new_ctx
== NULL
)) {
924 new_ctx
= null_context
;
927 tc
= talloc_chunk_from_ptr(ptr
);
929 if (unlikely(new_ctx
== NULL
)) {
931 _TLIST_REMOVE(tc
->parent
->child
, tc
);
932 if (tc
->parent
->child
) {
933 tc
->parent
->child
->parent
= tc
->parent
;
936 if (tc
->prev
) tc
->prev
->next
= tc
->next
;
937 if (tc
->next
) tc
->next
->prev
= tc
->prev
;
940 tc
->parent
= tc
->next
= tc
->prev
= NULL
;
941 return discard_const_p(void, ptr
);
944 new_tc
= talloc_chunk_from_ptr(new_ctx
);
946 if (unlikely(tc
== new_tc
|| tc
->parent
== new_tc
)) {
947 return discard_const_p(void, ptr
);
951 _TLIST_REMOVE(tc
->parent
->child
, tc
);
952 if (tc
->parent
->child
) {
953 tc
->parent
->child
->parent
= tc
->parent
;
956 if (tc
->prev
) tc
->prev
->next
= tc
->next
;
957 if (tc
->next
) tc
->next
->prev
= tc
->prev
;
961 if (new_tc
->child
) new_tc
->child
->parent
= NULL
;
962 _TLIST_ADD(new_tc
->child
, tc
);
964 return discard_const_p(void, ptr
);
968 move a lump of memory from one talloc context to another return the
969 ptr on success, or NULL if it could not be transferred.
970 passing NULL as ptr will always return NULL with no side effects.
972 _PUBLIC_
void *_talloc_steal_loc(const void *new_ctx
, const void *ptr
, const char *location
)
974 struct talloc_chunk
*tc
;
976 if (unlikely(ptr
== NULL
)) {
980 tc
= talloc_chunk_from_ptr(ptr
);
982 if (unlikely(tc
->refs
!= NULL
) && talloc_parent(ptr
) != new_ctx
) {
983 struct talloc_reference_handle
*h
;
985 talloc_log("WARNING: talloc_steal with references at %s\n",
988 for (h
=tc
->refs
; h
; h
=h
->next
) {
989 talloc_log("\treference at %s\n",
995 /* this test is probably too expensive to have on in the
996 normal build, but it useful for debugging */
997 if (talloc_is_parent(new_ctx
, ptr
)) {
998 talloc_log("WARNING: stealing into talloc child at %s\n", location
);
1002 return _talloc_steal_internal(new_ctx
, ptr
);
1006 this is like a talloc_steal(), but you must supply the old
1007 parent. This resolves the ambiguity in a talloc_steal() which is
1008 called on a context that has more than one parent (via references)
1010 The old parent can be either a reference or a parent
1012 _PUBLIC_
void *talloc_reparent(const void *old_parent
, const void *new_parent
, const void *ptr
)
1014 struct talloc_chunk
*tc
;
1015 struct talloc_reference_handle
*h
;
1017 if (unlikely(ptr
== NULL
)) {
1021 if (old_parent
== talloc_parent(ptr
)) {
1022 return _talloc_steal_internal(new_parent
, ptr
);
1025 tc
= talloc_chunk_from_ptr(ptr
);
1026 for (h
=tc
->refs
;h
;h
=h
->next
) {
1027 if (talloc_parent(h
) == old_parent
) {
1028 if (_talloc_steal_internal(new_parent
, h
) != h
) {
1031 return discard_const_p(void, ptr
);
1035 /* it wasn't a parent */
1040 remove a secondary reference to a pointer. This undo's what
1041 talloc_reference() has done. The context and pointer arguments
1042 must match those given to a talloc_reference()
1044 static inline int talloc_unreference(const void *context
, const void *ptr
)
1046 struct talloc_chunk
*tc
= talloc_chunk_from_ptr(ptr
);
1047 struct talloc_reference_handle
*h
;
1049 if (unlikely(context
== NULL
)) {
1050 context
= null_context
;
1053 for (h
=tc
->refs
;h
;h
=h
->next
) {
1054 struct talloc_chunk
*p
= talloc_parent_chunk(h
);
1056 if (context
== NULL
) break;
1057 } else if (TC_PTR_FROM_CHUNK(p
) == context
) {
1065 return _talloc_free_internal(h
, __location__
);
1069 remove a specific parent context from a pointer. This is a more
1070 controlled varient of talloc_free()
1072 _PUBLIC_
int talloc_unlink(const void *context
, void *ptr
)
1074 struct talloc_chunk
*tc_p
, *new_p
;
1081 if (context
== NULL
) {
1082 context
= null_context
;
1085 if (talloc_unreference(context
, ptr
) == 0) {
1089 if (context
== NULL
) {
1090 if (talloc_parent_chunk(ptr
) != NULL
) {
1094 if (talloc_chunk_from_ptr(context
) != talloc_parent_chunk(ptr
)) {
1099 tc_p
= talloc_chunk_from_ptr(ptr
);
1101 if (tc_p
->refs
== NULL
) {
1102 return _talloc_free_internal(ptr
, __location__
);
1105 new_p
= talloc_parent_chunk(tc_p
->refs
);
1107 new_parent
= TC_PTR_FROM_CHUNK(new_p
);
1112 if (talloc_unreference(new_parent
, ptr
) != 0) {
1116 _talloc_steal_internal(new_parent
, ptr
);
1122 add a name to an existing pointer - va_list version
1124 static inline const char *talloc_set_name_v(const void *ptr
, const char *fmt
, va_list ap
) PRINTF_ATTRIBUTE(2,0);
1126 static inline const char *talloc_set_name_v(const void *ptr
, const char *fmt
, va_list ap
)
1128 struct talloc_chunk
*tc
= talloc_chunk_from_ptr(ptr
);
1129 tc
->name
= talloc_vasprintf(ptr
, fmt
, ap
);
1130 if (likely(tc
->name
)) {
1131 _talloc_set_name_const(tc
->name
, ".name");
1137 add a name to an existing pointer
1139 _PUBLIC_
const char *talloc_set_name(const void *ptr
, const char *fmt
, ...)
1144 name
= talloc_set_name_v(ptr
, fmt
, ap
);
1151 create a named talloc pointer. Any talloc pointer can be named, and
1152 talloc_named() operates just like talloc() except that it allows you
1153 to name the pointer.
1155 _PUBLIC_
void *talloc_named(const void *context
, size_t size
, const char *fmt
, ...)
1161 ptr
= __talloc(context
, size
);
1162 if (unlikely(ptr
== NULL
)) return NULL
;
1165 name
= talloc_set_name_v(ptr
, fmt
, ap
);
1168 if (unlikely(name
== NULL
)) {
1169 _talloc_free_internal(ptr
, __location__
);
1177 return the name of a talloc ptr, or "UNNAMED"
1179 _PUBLIC_
const char *talloc_get_name(const void *ptr
)
1181 struct talloc_chunk
*tc
= talloc_chunk_from_ptr(ptr
);
1182 if (unlikely(tc
->name
== TALLOC_MAGIC_REFERENCE
)) {
1183 return ".reference";
1185 if (likely(tc
->name
)) {
1193 check if a pointer has the given name. If it does, return the pointer,
1194 otherwise return NULL
1196 _PUBLIC_
void *talloc_check_name(const void *ptr
, const char *name
)
1199 if (unlikely(ptr
== NULL
)) return NULL
;
1200 pname
= talloc_get_name(ptr
);
1201 if (likely(pname
== name
|| strcmp(pname
, name
) == 0)) {
1202 return discard_const_p(void, ptr
);
1207 static void talloc_abort_type_missmatch(const char *location
,
1209 const char *expected
)
1213 reason
= talloc_asprintf(NULL
,
1214 "%s: Type mismatch: name[%s] expected[%s]",
1219 reason
= "Type mismatch";
1222 talloc_abort(reason
);
1225 _PUBLIC_
void *_talloc_get_type_abort(const void *ptr
, const char *name
, const char *location
)
1229 if (unlikely(ptr
== NULL
)) {
1230 talloc_abort_type_missmatch(location
, NULL
, name
);
1234 pname
= talloc_get_name(ptr
);
1235 if (likely(pname
== name
|| strcmp(pname
, name
) == 0)) {
1236 return discard_const_p(void, ptr
);
1239 talloc_abort_type_missmatch(location
, pname
, name
);
1244 this is for compatibility with older versions of talloc
1246 _PUBLIC_
void *talloc_init(const char *fmt
, ...)
1252 ptr
= __talloc(NULL
, 0);
1253 if (unlikely(ptr
== NULL
)) return NULL
;
1256 name
= talloc_set_name_v(ptr
, fmt
, ap
);
1259 if (unlikely(name
== NULL
)) {
1260 _talloc_free_internal(ptr
, __location__
);
1268 this is a replacement for the Samba3 talloc_destroy_pool functionality. It
1269 should probably not be used in new code. It's in here to keep the talloc
1270 code consistent across Samba 3 and 4.
1272 _PUBLIC_
void talloc_free_children(void *ptr
)
1274 struct talloc_chunk
*tc
;
1276 if (unlikely(ptr
== NULL
)) {
1280 tc
= talloc_chunk_from_ptr(ptr
);
1283 /* we need to work out who will own an abandoned child
1284 if it cannot be freed. In priority order, the first
1285 choice is owner of any remaining reference to this
1286 pointer, the second choice is our parent, and the
1287 final choice is the null context. */
1288 void *child
= TC_PTR_FROM_CHUNK(tc
->child
);
1289 const void *new_parent
= null_context
;
1290 if (unlikely(tc
->child
->refs
)) {
1291 struct talloc_chunk
*p
= talloc_parent_chunk(tc
->child
->refs
);
1292 if (p
) new_parent
= TC_PTR_FROM_CHUNK(p
);
1294 if (unlikely(talloc_free(child
) == -1)) {
1295 if (new_parent
== null_context
) {
1296 struct talloc_chunk
*p
= talloc_parent_chunk(ptr
);
1297 if (p
) new_parent
= TC_PTR_FROM_CHUNK(p
);
1299 _talloc_steal_internal(new_parent
, child
);
1305 Allocate a bit of memory as a child of an existing pointer
1307 _PUBLIC_
void *_talloc(const void *context
, size_t size
)
1309 return __talloc(context
, size
);
1313 externally callable talloc_set_name_const()
1315 _PUBLIC_
void talloc_set_name_const(const void *ptr
, const char *name
)
1317 _talloc_set_name_const(ptr
, name
);
1321 create a named talloc pointer. Any talloc pointer can be named, and
1322 talloc_named() operates just like talloc() except that it allows you
1323 to name the pointer.
1325 _PUBLIC_
void *talloc_named_const(const void *context
, size_t size
, const char *name
)
1327 return _talloc_named_const(context
, size
, name
);
1331 free a talloc pointer. This also frees all child pointers of this
1334 return 0 if the memory is actually freed, otherwise -1. The memory
1335 will not be freed if the ref_count is > 1 or the destructor (if
1336 any) returns non-zero
1338 _PUBLIC_
int _talloc_free(void *ptr
, const char *location
)
1340 struct talloc_chunk
*tc
;
1342 if (unlikely(ptr
== NULL
)) {
1346 tc
= talloc_chunk_from_ptr(ptr
);
1348 if (unlikely(tc
->refs
!= NULL
)) {
1349 struct talloc_reference_handle
*h
;
1351 if (talloc_parent(ptr
) == null_context
&& tc
->refs
->next
== NULL
) {
1352 /* in this case we do know which parent should
1353 get this pointer, as there is really only
1355 return talloc_unlink(null_context
, ptr
);
1358 talloc_log("ERROR: talloc_free with references at %s\n",
1361 for (h
=tc
->refs
; h
; h
=h
->next
) {
1362 talloc_log("\treference at %s\n",
1368 return _talloc_free_internal(ptr
, location
);
1374 A talloc version of realloc. The context argument is only used if
1377 _PUBLIC_
void *_talloc_realloc(const void *context
, void *ptr
, size_t size
, const char *name
)
1379 struct talloc_chunk
*tc
;
1381 bool malloced
= false;
1382 struct talloc_chunk
*pool_tc
= NULL
;
1384 /* size zero is equivalent to free() */
1385 if (unlikely(size
== 0)) {
1386 talloc_unlink(context
, ptr
);
1390 if (unlikely(size
>= MAX_TALLOC_SIZE
)) {
1394 /* realloc(NULL) is equivalent to malloc() */
1396 return _talloc_named_const(context
, size
, name
);
1399 tc
= talloc_chunk_from_ptr(ptr
);
1401 /* don't allow realloc on referenced pointers */
1402 if (unlikely(tc
->refs
)) {
1406 /* don't let anybody try to realloc a talloc_pool */
1407 if (unlikely(tc
->flags
& TALLOC_FLAG_POOL
)) {
1411 /* don't let anybody try to realloc a talloc_pool */
1412 if (unlikely(tc
->flags
& TALLOC_FLAG_POOLMEM
)) {
1413 pool_tc
= (struct talloc_chunk
*)tc
->pool
;
1416 #if (ALWAYS_REALLOC == 0)
1417 /* don't shrink if we have less than 1k to gain */
1418 if (size
< tc
->size
) {
1420 void *next_tc
= TC_POOLMEM_NEXT_CHUNK(tc
);
1421 TC_INVALIDATE_SHRINK_CHUNK(tc
, size
);
1423 if (next_tc
== pool_tc
->pool
) {
1424 pool_tc
->pool
= TC_POOLMEM_NEXT_CHUNK(tc
);
1427 } else if ((tc
->size
- size
) < 1024) {
1429 * if we call TC_INVALIDATE_SHRINK_CHUNK() here
1430 * we would need to call TC_UNDEFINE_GROW_CHUNK()
1431 * after each realloc call, which slows down
1432 * testing a lot :-(.
1434 * That is why we only mark memory as undefined here.
1436 TC_UNDEFINE_SHRINK_CHUNK(tc
, size
);
1438 /* do not shrink if we have less than 1k to gain */
1442 } else if (tc
->size
== size
) {
1444 * do not change the pointer if it is exactly
1451 /* by resetting magic we catch users of the old memory */
1452 tc
->flags
|= TALLOC_FLAG_FREE
;
1456 new_ptr
= talloc_alloc_pool(tc
, size
+ TC_HDR_SIZE
);
1457 *talloc_pool_objectcount(pool_tc
) -= 1;
1459 if (new_ptr
== NULL
) {
1460 new_ptr
= malloc(TC_HDR_SIZE
+size
);
1465 memcpy(new_ptr
, tc
, MIN(tc
->size
,size
) + TC_HDR_SIZE
);
1466 TC_INVALIDATE_FULL_CHUNK(tc
);
1469 new_ptr
= malloc(size
+ TC_HDR_SIZE
);
1471 memcpy(new_ptr
, tc
, MIN(tc
->size
, size
) + TC_HDR_SIZE
);
1477 void *next_tc
= TC_POOLMEM_NEXT_CHUNK(tc
);
1478 size_t old_chunk_size
= TC_POOLMEM_CHUNK_SIZE(tc
);
1479 size_t new_chunk_size
= TC_ALIGN16(TC_HDR_SIZE
+ size
);
1480 size_t space_needed
;
1483 if (*talloc_pool_objectcount(pool_tc
) == 2) {
1485 * optimize for the case where 'tc' is the only
1486 * chunk in the pool.
1488 space_needed
= new_chunk_size
;
1489 space_left
= pool_tc
->size
- TALLOC_POOL_HDR_SIZE
;
1491 if (space_left
>= space_needed
) {
1492 size_t old_used
= TC_HDR_SIZE
+ tc
->size
;
1493 size_t new_used
= TC_HDR_SIZE
+ size
;
1494 pool_tc
->pool
= TC_POOL_FIRST_CHUNK(pool_tc
);
1495 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
1497 * we need to prepare the memmove into
1498 * the unaccessable area.
1501 size_t diff
= PTR_DIFF(tc
, pool_tc
->pool
);
1502 size_t flen
= MIN(diff
, old_used
);
1503 char *fptr
= (char *)pool_tc
->pool
;
1504 VALGRIND_MAKE_MEM_UNDEFINED(fptr
, flen
);
1507 memmove(pool_tc
->pool
, tc
, old_used
);
1508 new_ptr
= pool_tc
->pool
;
1510 TC_UNDEFINE_GROW_CHUNK(tc
, size
);
1513 * first we do not align the pool pointer
1514 * because we want to invalidate the padding
1517 pool_tc
->pool
= new_used
+ (char *)new_ptr
;
1518 TC_INVALIDATE_POOL(pool_tc
);
1520 /* now the aligned pointer */
1521 pool_tc
->pool
= new_chunk_size
+ (char *)new_ptr
;
1528 if (new_chunk_size
== old_chunk_size
) {
1529 TC_UNDEFINE_GROW_CHUNK(tc
, size
);
1530 tc
->flags
&= ~TALLOC_FLAG_FREE
;
1535 if (next_tc
== pool_tc
->pool
) {
1537 * optimize for the case where 'tc' is the last
1538 * chunk in the pool.
1540 space_needed
= new_chunk_size
- old_chunk_size
;
1541 space_left
= TC_POOL_SPACE_LEFT(pool_tc
);
1543 if (space_left
>= space_needed
) {
1544 TC_UNDEFINE_GROW_CHUNK(tc
, size
);
1545 tc
->flags
&= ~TALLOC_FLAG_FREE
;
1547 pool_tc
->pool
= TC_POOLMEM_NEXT_CHUNK(tc
);
1552 new_ptr
= talloc_alloc_pool(tc
, size
+ TC_HDR_SIZE
);
1553 *talloc_pool_objectcount(pool_tc
) -= 1;
1555 if (new_ptr
== NULL
) {
1556 new_ptr
= malloc(TC_HDR_SIZE
+size
);
1561 memcpy(new_ptr
, tc
, MIN(tc
->size
,size
) + TC_HDR_SIZE
);
1562 TC_INVALIDATE_FULL_CHUNK(tc
);
1564 if (*talloc_pool_objectcount(pool_tc
) == 1) {
1566 * If the pool is empty now reclaim everything.
1568 pool_tc
->pool
= TC_POOL_FIRST_CHUNK(pool_tc
);
1569 TC_INVALIDATE_POOL(pool_tc
);
1570 } else if (next_tc
== pool_tc
->pool
) {
1572 * If it was reallocated and tc was the last
1573 * chunk, we can reclaim the memory of tc.
1580 new_ptr
= realloc(tc
, size
+ TC_HDR_SIZE
);
1584 if (unlikely(!new_ptr
)) {
1585 tc
->flags
&= ~TALLOC_FLAG_FREE
;
1589 tc
= (struct talloc_chunk
*)new_ptr
;
1590 tc
->flags
&= ~TALLOC_FLAG_FREE
;
1592 tc
->flags
&= ~TALLOC_FLAG_POOLMEM
;
1595 tc
->parent
->child
= tc
;
1598 tc
->child
->parent
= tc
;
1602 tc
->prev
->next
= tc
;
1605 tc
->next
->prev
= tc
;
1609 _talloc_set_name_const(TC_PTR_FROM_CHUNK(tc
), name
);
1611 return TC_PTR_FROM_CHUNK(tc
);
1615 a wrapper around talloc_steal() for situations where you are moving a pointer
1616 between two structures, and want the old pointer to be set to NULL
1618 _PUBLIC_
void *_talloc_move(const void *new_ctx
, const void *_pptr
)
1620 const void **pptr
= discard_const_p(const void *,_pptr
);
1621 void *ret
= talloc_steal(new_ctx
, discard_const_p(void, *pptr
));
1627 return the total size of a talloc pool (subtree)
1629 _PUBLIC_
size_t talloc_total_size(const void *ptr
)
1632 struct talloc_chunk
*c
, *tc
;
1641 tc
= talloc_chunk_from_ptr(ptr
);
1643 if (tc
->flags
& TALLOC_FLAG_LOOP
) {
1647 tc
->flags
|= TALLOC_FLAG_LOOP
;
1649 if (likely(tc
->name
!= TALLOC_MAGIC_REFERENCE
)) {
1652 for (c
=tc
->child
;c
;c
=c
->next
) {
1653 total
+= talloc_total_size(TC_PTR_FROM_CHUNK(c
));
1656 tc
->flags
&= ~TALLOC_FLAG_LOOP
;
1662 return the total number of blocks in a talloc pool (subtree)
1664 _PUBLIC_
size_t talloc_total_blocks(const void *ptr
)
1667 struct talloc_chunk
*c
, *tc
;
1676 tc
= talloc_chunk_from_ptr(ptr
);
1678 if (tc
->flags
& TALLOC_FLAG_LOOP
) {
1682 tc
->flags
|= TALLOC_FLAG_LOOP
;
1685 for (c
=tc
->child
;c
;c
=c
->next
) {
1686 total
+= talloc_total_blocks(TC_PTR_FROM_CHUNK(c
));
1689 tc
->flags
&= ~TALLOC_FLAG_LOOP
;
1695 return the number of external references to a pointer
1697 _PUBLIC_
size_t talloc_reference_count(const void *ptr
)
1699 struct talloc_chunk
*tc
= talloc_chunk_from_ptr(ptr
);
1700 struct talloc_reference_handle
*h
;
1703 for (h
=tc
->refs
;h
;h
=h
->next
) {
1710 report on memory usage by all children of a pointer, giving a full tree view
1712 _PUBLIC_
void talloc_report_depth_cb(const void *ptr
, int depth
, int max_depth
,
1713 void (*callback
)(const void *ptr
,
1714 int depth
, int max_depth
,
1716 void *private_data
),
1719 struct talloc_chunk
*c
, *tc
;
1724 if (ptr
== NULL
) return;
1726 tc
= talloc_chunk_from_ptr(ptr
);
1728 if (tc
->flags
& TALLOC_FLAG_LOOP
) {
1732 callback(ptr
, depth
, max_depth
, 0, private_data
);
1734 if (max_depth
>= 0 && depth
>= max_depth
) {
1738 tc
->flags
|= TALLOC_FLAG_LOOP
;
1739 for (c
=tc
->child
;c
;c
=c
->next
) {
1740 if (c
->name
== TALLOC_MAGIC_REFERENCE
) {
1741 struct talloc_reference_handle
*h
= (struct talloc_reference_handle
*)TC_PTR_FROM_CHUNK(c
);
1742 callback(h
->ptr
, depth
+ 1, max_depth
, 1, private_data
);
1744 talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c
), depth
+ 1, max_depth
, callback
, private_data
);
1747 tc
->flags
&= ~TALLOC_FLAG_LOOP
;
1750 static void talloc_report_depth_FILE_helper(const void *ptr
, int depth
, int max_depth
, int is_ref
, void *_f
)
1752 const char *name
= talloc_get_name(ptr
);
1753 FILE *f
= (FILE *)_f
;
1756 fprintf(f
, "%*sreference to: %s\n", depth
*4, "", name
);
1761 fprintf(f
,"%stalloc report on '%s' (total %6lu bytes in %3lu blocks)\n",
1762 (max_depth
< 0 ? "full " :""), name
,
1763 (unsigned long)talloc_total_size(ptr
),
1764 (unsigned long)talloc_total_blocks(ptr
));
1768 fprintf(f
, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d) %p\n",
1771 (unsigned long)talloc_total_size(ptr
),
1772 (unsigned long)talloc_total_blocks(ptr
),
1773 (int)talloc_reference_count(ptr
), ptr
);
1776 fprintf(f
, "content: ");
1777 if (talloc_total_size(ptr
)) {
1778 int tot
= talloc_total_size(ptr
);
1781 for (i
= 0; i
< tot
; i
++) {
1782 if ((((char *)ptr
)[i
] > 31) && (((char *)ptr
)[i
] < 126)) {
1783 fprintf(f
, "%c", ((char *)ptr
)[i
]);
1785 fprintf(f
, "~%02x", ((char *)ptr
)[i
]);
1794 report on memory usage by all children of a pointer, giving a full tree view
1796 _PUBLIC_
void talloc_report_depth_file(const void *ptr
, int depth
, int max_depth
, FILE *f
)
1799 talloc_report_depth_cb(ptr
, depth
, max_depth
, talloc_report_depth_FILE_helper
, f
);
1805 report on memory usage by all children of a pointer, giving a full tree view
1807 _PUBLIC_
void talloc_report_full(const void *ptr
, FILE *f
)
1809 talloc_report_depth_file(ptr
, 0, -1, f
);
1813 report on memory usage by all children of a pointer
1815 _PUBLIC_
void talloc_report(const void *ptr
, FILE *f
)
1817 talloc_report_depth_file(ptr
, 0, 1, f
);
1821 report on any memory hanging off the null context
1823 static void talloc_report_null(void)
1825 if (talloc_total_size(null_context
) != 0) {
1826 talloc_report(null_context
, stderr
);
1831 report on any memory hanging off the null context
1833 static void talloc_report_null_full(void)
1835 if (talloc_total_size(null_context
) != 0) {
1836 talloc_report_full(null_context
, stderr
);
1841 enable tracking of the NULL context
1843 _PUBLIC_
void talloc_enable_null_tracking(void)
1845 if (null_context
== NULL
) {
1846 null_context
= _talloc_named_const(NULL
, 0, "null_context");
1847 if (autofree_context
!= NULL
) {
1848 talloc_reparent(NULL
, null_context
, autofree_context
);
1854 enable tracking of the NULL context, not moving the autofree context
1855 into the NULL context. This is needed for the talloc testsuite
1857 _PUBLIC_
void talloc_enable_null_tracking_no_autofree(void)
1859 if (null_context
== NULL
) {
1860 null_context
= _talloc_named_const(NULL
, 0, "null_context");
1865 disable tracking of the NULL context
1867 _PUBLIC_
void talloc_disable_null_tracking(void)
1869 if (null_context
!= NULL
) {
1870 /* we have to move any children onto the real NULL
1872 struct talloc_chunk
*tc
, *tc2
;
1873 tc
= talloc_chunk_from_ptr(null_context
);
1874 for (tc2
= tc
->child
; tc2
; tc2
=tc2
->next
) {
1875 if (tc2
->parent
== tc
) tc2
->parent
= NULL
;
1876 if (tc2
->prev
== tc
) tc2
->prev
= NULL
;
1878 for (tc2
= tc
->next
; tc2
; tc2
=tc2
->next
) {
1879 if (tc2
->parent
== tc
) tc2
->parent
= NULL
;
1880 if (tc2
->prev
== tc
) tc2
->prev
= NULL
;
1885 talloc_free(null_context
);
1886 null_context
= NULL
;
1890 enable leak reporting on exit
1892 _PUBLIC_
void talloc_enable_leak_report(void)
1894 talloc_enable_null_tracking();
1895 atexit(talloc_report_null
);
1899 enable full leak reporting on exit
1901 _PUBLIC_
void talloc_enable_leak_report_full(void)
1903 talloc_enable_null_tracking();
1904 atexit(talloc_report_null_full
);
1908 talloc and zero memory.
1910 _PUBLIC_
void *_talloc_zero(const void *ctx
, size_t size
, const char *name
)
1912 void *p
= _talloc_named_const(ctx
, size
, name
);
1915 memset(p
, '\0', size
);
1922 memdup with a talloc.
1924 _PUBLIC_
void *_talloc_memdup(const void *t
, const void *p
, size_t size
, const char *name
)
1926 void *newp
= _talloc_named_const(t
, size
, name
);
1929 memcpy(newp
, p
, size
);
1935 static inline char *__talloc_strlendup(const void *t
, const char *p
, size_t len
)
1939 ret
= (char *)__talloc(t
, len
+ 1);
1940 if (unlikely(!ret
)) return NULL
;
1942 memcpy(ret
, p
, len
);
1945 _talloc_set_name_const(ret
, ret
);
1950 strdup with a talloc
1952 _PUBLIC_
char *talloc_strdup(const void *t
, const char *p
)
1954 if (unlikely(!p
)) return NULL
;
1955 return __talloc_strlendup(t
, p
, strlen(p
));
1959 strndup with a talloc
1961 _PUBLIC_
char *talloc_strndup(const void *t
, const char *p
, size_t n
)
1963 if (unlikely(!p
)) return NULL
;
1964 return __talloc_strlendup(t
, p
, strnlen(p
, n
));
1967 static inline char *__talloc_strlendup_append(char *s
, size_t slen
,
1968 const char *a
, size_t alen
)
1972 ret
= talloc_realloc(NULL
, s
, char, slen
+ alen
+ 1);
1973 if (unlikely(!ret
)) return NULL
;
1975 /* append the string and the trailing \0 */
1976 memcpy(&ret
[slen
], a
, alen
);
1979 _talloc_set_name_const(ret
, ret
);
1984 * Appends at the end of the string.
1986 _PUBLIC_
char *talloc_strdup_append(char *s
, const char *a
)
1989 return talloc_strdup(NULL
, a
);
1996 return __talloc_strlendup_append(s
, strlen(s
), a
, strlen(a
));
2000 * Appends at the end of the talloc'ed buffer,
2001 * not the end of the string.
2003 _PUBLIC_
char *talloc_strdup_append_buffer(char *s
, const char *a
)
2008 return talloc_strdup(NULL
, a
);
2015 slen
= talloc_get_size(s
);
2016 if (likely(slen
> 0)) {
2020 return __talloc_strlendup_append(s
, slen
, a
, strlen(a
));
2024 * Appends at the end of the string.
2026 _PUBLIC_
char *talloc_strndup_append(char *s
, const char *a
, size_t n
)
2029 return talloc_strdup(NULL
, a
);
2036 return __talloc_strlendup_append(s
, strlen(s
), a
, strnlen(a
, n
));
2040 * Appends at the end of the talloc'ed buffer,
2041 * not the end of the string.
2043 _PUBLIC_
char *talloc_strndup_append_buffer(char *s
, const char *a
, size_t n
)
2048 return talloc_strdup(NULL
, a
);
2055 slen
= talloc_get_size(s
);
2056 if (likely(slen
> 0)) {
2060 return __talloc_strlendup_append(s
, slen
, a
, strnlen(a
, n
));
2063 #ifndef HAVE_VA_COPY
2064 #ifdef HAVE___VA_COPY
2065 #define va_copy(dest, src) __va_copy(dest, src)
2067 #define va_copy(dest, src) (dest) = (src)
2071 _PUBLIC_
char *talloc_vasprintf(const void *t
, const char *fmt
, va_list ap
)
2078 /* this call looks strange, but it makes it work on older solaris boxes */
2080 len
= vsnprintf(&c
, 1, fmt
, ap2
);
2082 if (unlikely(len
< 0)) {
2086 ret
= (char *)__talloc(t
, len
+1);
2087 if (unlikely(!ret
)) return NULL
;
2090 vsnprintf(ret
, len
+1, fmt
, ap2
);
2093 _talloc_set_name_const(ret
, ret
);
2099 Perform string formatting, and return a pointer to newly allocated
2100 memory holding the result, inside a memory pool.
2102 _PUBLIC_
char *talloc_asprintf(const void *t
, const char *fmt
, ...)
2108 ret
= talloc_vasprintf(t
, fmt
, ap
);
2113 static inline char *__talloc_vaslenprintf_append(char *s
, size_t slen
,
2114 const char *fmt
, va_list ap
)
2115 PRINTF_ATTRIBUTE(3,0);
2117 static inline char *__talloc_vaslenprintf_append(char *s
, size_t slen
,
2118 const char *fmt
, va_list ap
)
2125 alen
= vsnprintf(&c
, 1, fmt
, ap2
);
2129 /* Either the vsnprintf failed or the format resulted in
2130 * no characters being formatted. In the former case, we
2131 * ought to return NULL, in the latter we ought to return
2132 * the original string. Most current callers of this
2133 * function expect it to never return NULL.
2138 s
= talloc_realloc(NULL
, s
, char, slen
+ alen
+ 1);
2139 if (!s
) return NULL
;
2142 vsnprintf(s
+ slen
, alen
+ 1, fmt
, ap2
);
2145 _talloc_set_name_const(s
, s
);
2150 * Realloc @p s to append the formatted result of @p fmt and @p ap,
2151 * and return @p s, which may have moved. Good for gradually
2152 * accumulating output into a string buffer. Appends at the end
2155 _PUBLIC_
char *talloc_vasprintf_append(char *s
, const char *fmt
, va_list ap
)
2158 return talloc_vasprintf(NULL
, fmt
, ap
);
2161 return __talloc_vaslenprintf_append(s
, strlen(s
), fmt
, ap
);
2165 * Realloc @p s to append the formatted result of @p fmt and @p ap,
2166 * and return @p s, which may have moved. Always appends at the
2167 * end of the talloc'ed buffer, not the end of the string.
2169 _PUBLIC_
char *talloc_vasprintf_append_buffer(char *s
, const char *fmt
, va_list ap
)
2174 return talloc_vasprintf(NULL
, fmt
, ap
);
2177 slen
= talloc_get_size(s
);
2178 if (likely(slen
> 0)) {
2182 return __talloc_vaslenprintf_append(s
, slen
, fmt
, ap
);
2186 Realloc @p s to append the formatted result of @p fmt and return @p
2187 s, which may have moved. Good for gradually accumulating output
2188 into a string buffer.
2190 _PUBLIC_
char *talloc_asprintf_append(char *s
, const char *fmt
, ...)
2195 s
= talloc_vasprintf_append(s
, fmt
, ap
);
2201 Realloc @p s to append the formatted result of @p fmt and return @p
2202 s, which may have moved. Good for gradually accumulating output
2205 _PUBLIC_
char *talloc_asprintf_append_buffer(char *s
, const char *fmt
, ...)
2210 s
= talloc_vasprintf_append_buffer(s
, fmt
, ap
);
2216 alloc an array, checking for integer overflow in the array size
2218 _PUBLIC_
void *_talloc_array(const void *ctx
, size_t el_size
, unsigned count
, const char *name
)
2220 if (count
>= MAX_TALLOC_SIZE
/el_size
) {
2223 return _talloc_named_const(ctx
, el_size
* count
, name
);
2227 alloc an zero array, checking for integer overflow in the array size
2229 _PUBLIC_
void *_talloc_zero_array(const void *ctx
, size_t el_size
, unsigned count
, const char *name
)
2231 if (count
>= MAX_TALLOC_SIZE
/el_size
) {
2234 return _talloc_zero(ctx
, el_size
* count
, name
);
2238 realloc an array, checking for integer overflow in the array size
2240 _PUBLIC_
void *_talloc_realloc_array(const void *ctx
, void *ptr
, size_t el_size
, unsigned count
, const char *name
)
2242 if (count
>= MAX_TALLOC_SIZE
/el_size
) {
2245 return _talloc_realloc(ctx
, ptr
, el_size
* count
, name
);
2249 a function version of talloc_realloc(), so it can be passed as a function pointer
2250 to libraries that want a realloc function (a realloc function encapsulates
2251 all the basic capabilities of an allocation library, which is why this is useful)
2253 _PUBLIC_
void *talloc_realloc_fn(const void *context
, void *ptr
, size_t size
)
2255 return _talloc_realloc(context
, ptr
, size
, NULL
);
2259 static int talloc_autofree_destructor(void *ptr
)
2261 autofree_context
= NULL
;
2265 static void talloc_autofree(void)
2267 talloc_free(autofree_context
);
2271 return a context which will be auto-freed on exit
2272 this is useful for reducing the noise in leak reports
2274 _PUBLIC_
void *talloc_autofree_context(void)
2276 if (autofree_context
== NULL
) {
2277 autofree_context
= _talloc_named_const(NULL
, 0, "autofree_context");
2278 talloc_set_destructor(autofree_context
, talloc_autofree_destructor
);
2279 atexit(talloc_autofree
);
2281 return autofree_context
;
2284 _PUBLIC_
size_t talloc_get_size(const void *context
)
2286 struct talloc_chunk
*tc
;
2288 if (context
== NULL
) {
2289 context
= null_context
;
2291 if (context
== NULL
) {
2295 tc
= talloc_chunk_from_ptr(context
);
2301 find a parent of this context that has the given name, if any
2303 _PUBLIC_
void *talloc_find_parent_byname(const void *context
, const char *name
)
2305 struct talloc_chunk
*tc
;
2307 if (context
== NULL
) {
2311 tc
= talloc_chunk_from_ptr(context
);
2313 if (tc
->name
&& strcmp(tc
->name
, name
) == 0) {
2314 return TC_PTR_FROM_CHUNK(tc
);
2316 while (tc
&& tc
->prev
) tc
= tc
->prev
;
2325 show the parentage of a context
2327 _PUBLIC_
void talloc_show_parents(const void *context
, FILE *file
)
2329 struct talloc_chunk
*tc
;
2331 if (context
== NULL
) {
2332 fprintf(file
, "talloc no parents for NULL\n");
2336 tc
= talloc_chunk_from_ptr(context
);
2337 fprintf(file
, "talloc parents of '%s'\n", talloc_get_name(context
));
2339 fprintf(file
, "\t'%s'\n", talloc_get_name(TC_PTR_FROM_CHUNK(tc
)));
2340 while (tc
&& tc
->prev
) tc
= tc
->prev
;
2349 return 1 if ptr is a parent of context
2351 static int _talloc_is_parent(const void *context
, const void *ptr
, int depth
)
2353 struct talloc_chunk
*tc
;
2355 if (context
== NULL
) {
2359 tc
= talloc_chunk_from_ptr(context
);
2360 while (tc
&& depth
> 0) {
2361 if (TC_PTR_FROM_CHUNK(tc
) == ptr
) return 1;
2362 while (tc
&& tc
->prev
) tc
= tc
->prev
;
2372 return 1 if ptr is a parent of context
2374 _PUBLIC_
int talloc_is_parent(const void *context
, const void *ptr
)
2376 return _talloc_is_parent(context
, ptr
, TALLOC_MAX_DEPTH
);