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/
35 #if (SAMBA_VERSION_MAJOR<4)
37 /* This is to circumvent SAMBA3's paranoid malloc checker. Here in this file
38 * we trust ourselves... */
45 #define _TALLOC_SAMBA3
46 #endif /* (SAMBA_VERSION_MAJOR<4) */
47 #endif /* _SAMBA_BUILD_ */
49 #ifndef _TALLOC_SAMBA3
50 //#include "replace.h"
57 #include <osmocom/core/talloc.h>
58 #define MIN(x,y) ((x) < (y) ? (x) : (y))
59 #endif /* not _TALLOC_SAMBA3 */
61 /* use this to force every realloc to change the pointer, to stress test
62 code that might not cope */
63 #define ALWAYS_REALLOC 0
66 #define MAX_TALLOC_SIZE 0x10000000
67 #define TALLOC_MAGIC 0xe814ec70
68 #define TALLOC_FLAG_FREE 0x01
69 #define TALLOC_FLAG_LOOP 0x02
70 #define TALLOC_FLAG_POOL 0x04 /* This is a talloc pool */
71 #define TALLOC_FLAG_POOLMEM 0x08 /* This is allocated in a pool */
72 #define TALLOC_MAGIC_REFERENCE ((const char *)1)
74 /* by default we abort when given a bad pointer (such as when talloc_free() is called
75 on a pointer that came from malloc() */
77 #define TALLOC_ABORT(reason) abort()
80 #ifndef discard_const_p
81 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
82 # define discard_const_p(type, ptr) ((type *)((intptr_t)(ptr)))
84 # define discard_const_p(type, ptr) ((type *)(ptr))
88 /* these macros gain us a few percent of speed on gcc */
90 /* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
91 as its first argument */
93 #define likely(x) __builtin_expect(!!(x), 1)
96 #define unlikely(x) __builtin_expect(!!(x), 0)
100 #define likely(x) (x)
103 #define unlikely(x) (x)
108 /* taken from http://insanecoding.blogspot.com/2007/03/methods-for-safe-string-handling.html */
109 size_t strnlen(const char *s, size_t n)
111 const char *p = (const char *)memchr(s, 0, n);
116 /* this null_context is only used if talloc_enable_leak_report() or
117 talloc_enable_leak_report_full() is called, otherwise it remains
120 static void *null_context;
121 static void *autofree_context;
123 struct talloc_reference_handle {
124 struct talloc_reference_handle *next, *prev;
128 typedef int (*talloc_destructor_t)(void *);
130 struct talloc_chunk {
131 struct talloc_chunk *next, *prev;
132 struct talloc_chunk *parent, *child;
133 struct talloc_reference_handle *refs;
134 talloc_destructor_t destructor;
140 * "pool" has dual use:
142 * For the talloc pool itself (i.e. TALLOC_FLAG_POOL is set), "pool"
143 * marks the end of the currently allocated area.
145 * For members of the pool (i.e. TALLOC_FLAG_POOLMEM is set), "pool"
146 * is a pointer to the struct talloc_chunk of the pool that it was
147 * allocated from. This way children can quickly find the pool to chew
153 /* 16 byte alignment seems to keep everyone happy */
154 #define TC_HDR_SIZE ((sizeof(struct talloc_chunk)+15)&~15)
155 #define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
157 static void (*talloc_abort_fn)(const char *reason);
159 void talloc_set_abort_fn(void (*abort_fn)(const char *reason))
161 talloc_abort_fn = abort_fn;
164 static void talloc_abort(const char *reason)
166 if (!talloc_abort_fn) {
167 TALLOC_ABORT(reason);
170 talloc_abort_fn(reason);
173 static void talloc_abort_double_free(void)
175 talloc_abort("Bad talloc magic value - double free");
178 static void talloc_abort_unknown_value(void)
180 talloc_abort("Bad talloc magic value - unknown value");
183 /* panic if we get a bad magic value */
184 static inline struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
186 const char *pp = (const char *)ptr;
187 struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp - TC_HDR_SIZE);
188 if (unlikely((tc->flags & (TALLOC_FLAG_FREE | ~0xF)) != TALLOC_MAGIC)) {
189 if (tc->flags & TALLOC_FLAG_FREE) {
190 talloc_abort_double_free();
192 talloc_abort_unknown_value();
198 /* hook into the front of the list */
199 #define _TLIST_ADD(list, p) \
203 (p)->next = (p)->prev = NULL; \
205 (list)->prev = (p); \
206 (p)->next = (list); \
212 /* remove an element from a list - element doesn't have to be in list. */
213 #define _TLIST_REMOVE(list, p) \
215 if ((p) == (list)) { \
216 (list) = (p)->next; \
217 if (list) (list)->prev = NULL; \
219 if ((p)->prev) (p)->prev->next = (p)->next; \
220 if ((p)->next) (p)->next->prev = (p)->prev; \
222 if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \
227 return the parent chunk of a pointer
229 static inline struct talloc_chunk *talloc_parent_chunk(const void *ptr)
231 struct talloc_chunk *tc;
233 if (unlikely(ptr == NULL)) {
237 tc = talloc_chunk_from_ptr(ptr);
238 while (tc->prev) tc=tc->prev;
243 void *talloc_parent(const void *ptr)
245 struct talloc_chunk *tc = talloc_parent_chunk(ptr);
246 return tc? TC_PTR_FROM_CHUNK(tc) : NULL;
252 const char *talloc_parent_name(const void *ptr)
254 struct talloc_chunk *tc = talloc_parent_chunk(ptr);
255 return tc? tc->name : NULL;
259 A pool carries an in-pool object count count in the first 16 bytes.
260 bytes. This is done to support talloc_steal() to a parent outside of the
261 pool. The count includes the pool itself, so a talloc_free() on a pool will
262 only destroy the pool if the count has dropped to zero. A talloc_free() of a
263 pool member will reduce the count, and eventually also call free(3) on the
266 The object count is not put into "struct talloc_chunk" because it is only
267 relevant for talloc pools and the alignment to 16 bytes would increase the
268 memory footprint of each talloc chunk by those 16 bytes.
271 #define TALLOC_POOL_HDR_SIZE 16
273 static unsigned int *talloc_pool_objectcount(struct talloc_chunk *tc)
275 return (unsigned int *)((char *)tc + sizeof(struct talloc_chunk));
282 static struct talloc_chunk *talloc_alloc_pool(struct talloc_chunk *parent,
285 struct talloc_chunk *pool_ctx = NULL;
287 struct talloc_chunk *result;
290 if (parent == NULL) {
294 if (parent->flags & TALLOC_FLAG_POOL) {
297 else if (parent->flags & TALLOC_FLAG_POOLMEM) {
298 pool_ctx = (struct talloc_chunk *)parent->pool;
301 if (pool_ctx == NULL) {
305 space_left = ((char *)pool_ctx + TC_HDR_SIZE + pool_ctx->size)
306 - ((char *)pool_ctx->pool);
309 * Align size to 16 bytes
311 chunk_size = ((size + 15) & ~15);
313 if (space_left < chunk_size) {
317 result = (struct talloc_chunk *)pool_ctx->pool;
319 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
320 VALGRIND_MAKE_MEM_UNDEFINED(result, size);
323 pool_ctx->pool = (void *)((char *)result + chunk_size);
325 result->flags = TALLOC_MAGIC | TALLOC_FLAG_POOLMEM;
326 result->pool = pool_ctx;
328 *talloc_pool_objectcount(pool_ctx) += 1;
334 Allocate a bit of memory as a child of an existing pointer
336 static inline void *__talloc(const void *context, size_t size)
338 struct talloc_chunk *tc = NULL;
340 if (unlikely(context == NULL)) {
341 context = null_context;
344 if (unlikely(size >= MAX_TALLOC_SIZE)) {
348 if (context != NULL) {
349 tc = talloc_alloc_pool(talloc_chunk_from_ptr(context),
354 tc = (struct talloc_chunk *)malloc(TC_HDR_SIZE+size);
355 if (unlikely(tc == NULL)) return NULL;
356 tc->flags = TALLOC_MAGIC;
361 tc->destructor = NULL;
366 if (likely(context)) {
367 struct talloc_chunk *parent = talloc_chunk_from_ptr(context);
370 parent->child->parent = NULL;
371 tc->next = parent->child;
380 tc->next = tc->prev = tc->parent = NULL;
383 return TC_PTR_FROM_CHUNK(tc);
387 * Create a talloc pool
390 void *talloc_pool(const void *context, size_t size)
392 void *result = __talloc(context, size + TALLOC_POOL_HDR_SIZE);
393 struct talloc_chunk *tc;
395 if (unlikely(result == NULL)) {
399 tc = talloc_chunk_from_ptr(result);
401 tc->flags |= TALLOC_FLAG_POOL;
402 tc->pool = (char *)result + TALLOC_POOL_HDR_SIZE;
404 *talloc_pool_objectcount(tc) = 1;
406 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
407 VALGRIND_MAKE_MEM_NOACCESS(tc->pool, size);
414 setup a destructor to be called on free of a pointer
415 the destructor should return 0 on success, or -1 on failure.
416 if the destructor fails then the free is failed, and the memory can
417 be continued to be used
419 void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
421 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
422 tc->destructor = destructor;
426 increase the reference count on a piece of memory.
428 int talloc_increase_ref_count(const void *ptr)
430 if (unlikely(!talloc_reference(null_context, ptr))) {
437 helper for talloc_reference()
439 this is referenced by a function pointer and should not be inline
441 static int talloc_reference_destructor(struct talloc_reference_handle *handle)
443 struct talloc_chunk *ptr_tc = talloc_chunk_from_ptr(handle->ptr);
444 _TLIST_REMOVE(ptr_tc->refs, handle);
449 more efficient way to add a name to a pointer - the name must point to a
452 static inline void _talloc_set_name_const(const void *ptr, const char *name)
454 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
459 internal talloc_named_const()
461 static inline void *_talloc_named_const(const void *context, size_t size, const char *name)
465 ptr = __talloc(context, size);
466 if (unlikely(ptr == NULL)) {
470 _talloc_set_name_const(ptr, name);
476 make a secondary reference to a pointer, hanging off the given context.
477 the pointer remains valid until both the original caller and this given
480 the major use for this is when two different structures need to reference the
481 same underlying data, and you want to be able to free the two instances separately,
484 void *_talloc_reference(const void *context, const void *ptr)
486 struct talloc_chunk *tc;
487 struct talloc_reference_handle *handle;
488 if (unlikely(ptr == NULL)) return NULL;
490 tc = talloc_chunk_from_ptr(ptr);
491 handle = (struct talloc_reference_handle *)_talloc_named_const(context,
492 sizeof(struct talloc_reference_handle),
493 TALLOC_MAGIC_REFERENCE);
494 if (unlikely(handle == NULL)) return NULL;
496 /* note that we hang the destructor off the handle, not the
497 main context as that allows the caller to still setup their
498 own destructor on the context if they want to */
499 talloc_set_destructor(handle, talloc_reference_destructor);
500 handle->ptr = discard_const_p(void, ptr);
501 _TLIST_ADD(tc->refs, handle);
507 internal talloc_free call
509 static inline int _talloc_free(void *ptr)
511 struct talloc_chunk *tc;
513 if (unlikely(ptr == NULL)) {
517 tc = talloc_chunk_from_ptr(ptr);
519 if (unlikely(tc->refs)) {
521 /* check this is a reference from a child or grantchild
522 * back to it's parent or grantparent
524 * in that case we need to remove the reference and
525 * call another instance of talloc_free() on the current
528 is_child = talloc_is_parent(tc->refs, ptr);
529 _talloc_free(tc->refs);
531 return _talloc_free(ptr);
536 if (unlikely(tc->flags & TALLOC_FLAG_LOOP)) {
537 /* we have a free loop - stop looping */
541 if (unlikely(tc->destructor)) {
542 talloc_destructor_t d = tc->destructor;
543 if (d == (talloc_destructor_t)-1) {
546 tc->destructor = (talloc_destructor_t)-1;
551 tc->destructor = NULL;
555 _TLIST_REMOVE(tc->parent->child, tc);
556 if (tc->parent->child) {
557 tc->parent->child->parent = tc->parent;
560 if (tc->prev) tc->prev->next = tc->next;
561 if (tc->next) tc->next->prev = tc->prev;
564 tc->flags |= TALLOC_FLAG_LOOP;
567 /* we need to work out who will own an abandoned child
568 if it cannot be freed. In priority order, the first
569 choice is owner of any remaining reference to this
570 pointer, the second choice is our parent, and the
571 final choice is the null context. */
572 void *child = TC_PTR_FROM_CHUNK(tc->child);
573 const void *new_parent = null_context;
574 if (unlikely(tc->child->refs)) {
575 struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
576 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
578 if (unlikely(_talloc_free(child) == -1)) {
579 if (new_parent == null_context) {
580 struct talloc_chunk *p = talloc_parent_chunk(ptr);
581 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
583 talloc_steal(new_parent, child);
587 tc->flags |= TALLOC_FLAG_FREE;
589 if (tc->flags & (TALLOC_FLAG_POOL|TALLOC_FLAG_POOLMEM)) {
590 struct talloc_chunk *pool;
591 unsigned int *pool_object_count;
593 pool = (tc->flags & TALLOC_FLAG_POOL)
594 ? tc : (struct talloc_chunk *)tc->pool;
596 pool_object_count = talloc_pool_objectcount(pool);
598 if (*pool_object_count == 0) {
599 talloc_abort("Pool object count zero!");
602 *pool_object_count -= 1;
604 if (*pool_object_count == 0) {
615 move a lump of memory from one talloc context to another return the
616 ptr on success, or NULL if it could not be transferred.
617 passing NULL as ptr will always return NULL with no side effects.
619 void *_talloc_steal(const void *new_ctx, const void *ptr)
621 struct talloc_chunk *tc, *new_tc;
623 if (unlikely(!ptr)) {
627 if (unlikely(new_ctx == NULL)) {
628 new_ctx = null_context;
631 tc = talloc_chunk_from_ptr(ptr);
633 if (unlikely(new_ctx == NULL)) {
635 _TLIST_REMOVE(tc->parent->child, tc);
636 if (tc->parent->child) {
637 tc->parent->child->parent = tc->parent;
640 if (tc->prev) tc->prev->next = tc->next;
641 if (tc->next) tc->next->prev = tc->prev;
644 tc->parent = tc->next = tc->prev = NULL;
645 return discard_const_p(void, ptr);
648 new_tc = talloc_chunk_from_ptr(new_ctx);
650 if (unlikely(tc == new_tc || tc->parent == new_tc)) {
651 return discard_const_p(void, ptr);
655 _TLIST_REMOVE(tc->parent->child, tc);
656 if (tc->parent->child) {
657 tc->parent->child->parent = tc->parent;
660 if (tc->prev) tc->prev->next = tc->next;
661 if (tc->next) tc->next->prev = tc->prev;
665 if (new_tc->child) new_tc->child->parent = NULL;
666 _TLIST_ADD(new_tc->child, tc);
668 return discard_const_p(void, ptr);
674 remove a secondary reference to a pointer. This undo's what
675 talloc_reference() has done. The context and pointer arguments
676 must match those given to a talloc_reference()
678 static inline int talloc_unreference(const void *context, const void *ptr)
680 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
681 struct talloc_reference_handle *h;
683 if (unlikely(context == NULL)) {
684 context = null_context;
687 for (h=tc->refs;h;h=h->next) {
688 struct talloc_chunk *p = talloc_parent_chunk(h);
690 if (context == NULL) break;
691 } else if (TC_PTR_FROM_CHUNK(p) == context) {
699 return _talloc_free(h);
703 remove a specific parent context from a pointer. This is a more
704 controlled varient of talloc_free()
706 int talloc_unlink(const void *context, void *ptr)
708 struct talloc_chunk *tc_p, *new_p;
715 if (context == NULL) {
716 context = null_context;
719 if (talloc_unreference(context, ptr) == 0) {
723 if (context == NULL) {
724 if (talloc_parent_chunk(ptr) != NULL) {
728 if (talloc_chunk_from_ptr(context) != talloc_parent_chunk(ptr)) {
733 tc_p = talloc_chunk_from_ptr(ptr);
735 if (tc_p->refs == NULL) {
736 return _talloc_free(ptr);
739 new_p = talloc_parent_chunk(tc_p->refs);
741 new_parent = TC_PTR_FROM_CHUNK(new_p);
746 if (talloc_unreference(new_parent, ptr) != 0) {
750 talloc_steal(new_parent, ptr);
756 add a name to an existing pointer - va_list version
758 static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
760 static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
762 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
763 tc->name = talloc_vasprintf(ptr, fmt, ap);
764 if (likely(tc->name)) {
765 _talloc_set_name_const(tc->name, ".name");
771 add a name to an existing pointer
773 const char *talloc_set_name(const void *ptr, const char *fmt, ...)
778 name = talloc_set_name_v(ptr, fmt, ap);
785 create a named talloc pointer. Any talloc pointer can be named, and
786 talloc_named() operates just like talloc() except that it allows you
789 void *talloc_named(const void *context, size_t size, const char *fmt, ...)
795 ptr = __talloc(context, size);
796 if (unlikely(ptr == NULL)) return NULL;
799 name = talloc_set_name_v(ptr, fmt, ap);
802 if (unlikely(name == NULL)) {
811 return the name of a talloc ptr, or "UNNAMED"
813 const char *talloc_get_name(const void *ptr)
815 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
816 if (unlikely(tc->name == TALLOC_MAGIC_REFERENCE)) {
819 if (likely(tc->name)) {
827 check if a pointer has the given name. If it does, return the pointer,
828 otherwise return NULL
830 void *talloc_check_name(const void *ptr, const char *name)
833 if (unlikely(ptr == NULL)) return NULL;
834 pname = talloc_get_name(ptr);
835 if (likely(pname == name || strcmp(pname, name) == 0)) {
836 return discard_const_p(void, ptr);
841 static void talloc_abort_type_missmatch(const char *location,
843 const char *expected)
847 reason = talloc_asprintf(NULL,
848 "%s: Type mismatch: name[%s] expected[%s]",
853 reason = "Type mismatch";
856 talloc_abort(reason);
859 void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location)
863 if (unlikely(ptr == NULL)) {
864 talloc_abort_type_missmatch(location, NULL, name);
868 pname = talloc_get_name(ptr);
869 if (likely(pname == name || strcmp(pname, name) == 0)) {
870 return discard_const_p(void, ptr);
873 talloc_abort_type_missmatch(location, pname, name);
878 this is for compatibility with older versions of talloc
880 void *talloc_init(const char *fmt, ...)
887 * samba3 expects talloc_report_depth_cb(NULL, ...)
888 * reports all talloc'ed memory, so we need to enable
891 talloc_enable_null_tracking();
893 ptr = __talloc(NULL, 0);
894 if (unlikely(ptr == NULL)) return NULL;
897 name = talloc_set_name_v(ptr, fmt, ap);
900 if (unlikely(name == NULL)) {
909 this is a replacement for the Samba3 talloc_destroy_pool functionality. It
910 should probably not be used in new code. It's in here to keep the talloc
911 code consistent across Samba 3 and 4.
913 void talloc_free_children(void *ptr)
915 struct talloc_chunk *tc;
917 if (unlikely(ptr == NULL)) {
921 tc = talloc_chunk_from_ptr(ptr);
924 /* we need to work out who will own an abandoned child
925 if it cannot be freed. In priority order, the first
926 choice is owner of any remaining reference to this
927 pointer, the second choice is our parent, and the
928 final choice is the null context. */
929 void *child = TC_PTR_FROM_CHUNK(tc->child);
930 const void *new_parent = null_context;
931 if (unlikely(tc->child->refs)) {
932 struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
933 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
935 if (unlikely(_talloc_free(child) == -1)) {
936 if (new_parent == null_context) {
937 struct talloc_chunk *p = talloc_parent_chunk(ptr);
938 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
940 talloc_steal(new_parent, child);
944 if ((tc->flags & TALLOC_FLAG_POOL)
945 && (*talloc_pool_objectcount(tc) == 1)) {
946 tc->pool = ((char *)tc + TC_HDR_SIZE + TALLOC_POOL_HDR_SIZE);
947 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
948 VALGRIND_MAKE_MEM_NOACCESS(
949 tc->pool, tc->size - TALLOC_POOL_HDR_SIZE);
955 Allocate a bit of memory as a child of an existing pointer
957 void *_talloc(const void *context, size_t size)
959 return __talloc(context, size);
963 externally callable talloc_set_name_const()
965 void talloc_set_name_const(const void *ptr, const char *name)
967 _talloc_set_name_const(ptr, name);
971 create a named talloc pointer. Any talloc pointer can be named, and
972 talloc_named() operates just like talloc() except that it allows you
975 void *talloc_named_const(const void *context, size_t size, const char *name)
977 return _talloc_named_const(context, size, name);
981 free a talloc pointer. This also frees all child pointers of this
984 return 0 if the memory is actually freed, otherwise -1. The memory
985 will not be freed if the ref_count is > 1 or the destructor (if
986 any) returns non-zero
988 int talloc_free(void *ptr)
990 return _talloc_free(ptr);
996 A talloc version of realloc. The context argument is only used if
999 void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name)
1001 struct talloc_chunk *tc;
1003 bool malloced = false;
1005 /* size zero is equivalent to free() */
1006 if (unlikely(size == 0)) {
1011 if (unlikely(size >= MAX_TALLOC_SIZE)) {
1015 /* realloc(NULL) is equivalent to malloc() */
1017 return _talloc_named_const(context, size, name);
1020 tc = talloc_chunk_from_ptr(ptr);
1022 /* don't allow realloc on referenced pointers */
1023 if (unlikely(tc->refs)) {
1027 /* don't let anybody try to realloc a talloc_pool */
1028 if (unlikely(tc->flags & TALLOC_FLAG_POOL)) {
1032 /* don't shrink if we have less than 1k to gain */
1033 if ((size < tc->size) && ((tc->size - size) < 1024)) {
1038 /* by resetting magic we catch users of the old memory */
1039 tc->flags |= TALLOC_FLAG_FREE;
1042 new_ptr = malloc(size + TC_HDR_SIZE);
1044 memcpy(new_ptr, tc, tc->size + TC_HDR_SIZE);
1048 if (tc->flags & TALLOC_FLAG_POOLMEM) {
1050 new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE);
1051 *talloc_pool_objectcount((struct talloc_chunk *)
1054 if (new_ptr == NULL) {
1055 new_ptr = malloc(TC_HDR_SIZE+size);
1060 memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE);
1064 new_ptr = realloc(tc, size + TC_HDR_SIZE);
1067 if (unlikely(!new_ptr)) {
1068 tc->flags &= ~TALLOC_FLAG_FREE;
1072 tc = (struct talloc_chunk *)new_ptr;
1073 tc->flags &= ~TALLOC_FLAG_FREE;
1075 tc->flags &= ~TALLOC_FLAG_POOLMEM;
1078 tc->parent->child = tc;
1081 tc->child->parent = tc;
1085 tc->prev->next = tc;
1088 tc->next->prev = tc;
1092 _talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
1094 return TC_PTR_FROM_CHUNK(tc);
1098 a wrapper around talloc_steal() for situations where you are moving a pointer
1099 between two structures, and want the old pointer to be set to NULL
1101 void *_talloc_move(const void *new_ctx, const void *_pptr)
1103 const void **pptr = discard_const_p(const void *,_pptr);
1104 void *ret = _talloc_steal(new_ctx, *pptr);
1110 return the total size of a talloc pool (subtree)
1112 size_t talloc_total_size(const void *ptr)
1115 struct talloc_chunk *c, *tc;
1124 tc = talloc_chunk_from_ptr(ptr);
1126 if (tc->flags & TALLOC_FLAG_LOOP) {
1130 tc->flags |= TALLOC_FLAG_LOOP;
1133 for (c=tc->child;c;c=c->next) {
1134 total += talloc_total_size(TC_PTR_FROM_CHUNK(c));
1137 tc->flags &= ~TALLOC_FLAG_LOOP;
1143 return the total number of blocks in a talloc pool (subtree)
1145 size_t talloc_total_blocks(const void *ptr)
1148 struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
1150 if (tc->flags & TALLOC_FLAG_LOOP) {
1154 tc->flags |= TALLOC_FLAG_LOOP;
1157 for (c=tc->child;c;c=c->next) {
1158 total += talloc_total_blocks(TC_PTR_FROM_CHUNK(c));
1161 tc->flags &= ~TALLOC_FLAG_LOOP;
1167 return the number of external references to a pointer
1169 size_t talloc_reference_count(const void *ptr)
1171 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1172 struct talloc_reference_handle *h;
1175 for (h=tc->refs;h;h=h->next) {
1182 report on memory usage by all children of a pointer, giving a full tree view
1184 void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
1185 void (*callback)(const void *ptr,
1186 int depth, int max_depth,
1188 void *private_data),
1191 struct talloc_chunk *c, *tc;
1196 if (ptr == NULL) return;
1198 tc = talloc_chunk_from_ptr(ptr);
1200 if (tc->flags & TALLOC_FLAG_LOOP) {
1204 callback(ptr, depth, max_depth, 0, private_data);
1206 if (max_depth >= 0 && depth >= max_depth) {
1210 tc->flags |= TALLOC_FLAG_LOOP;
1211 for (c=tc->child;c;c=c->next) {
1212 if (c->name == TALLOC_MAGIC_REFERENCE) {
1213 struct talloc_reference_handle *h = (struct talloc_reference_handle *)TC_PTR_FROM_CHUNK(c);
1214 callback(h->ptr, depth + 1, max_depth, 1, private_data);
1216 talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c), depth + 1, max_depth, callback, private_data);
1219 tc->flags &= ~TALLOC_FLAG_LOOP;
1222 static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_depth, int is_ref, void *_f)
1224 const char *name = talloc_get_name(ptr);
1225 FILE *f = (FILE *)_f;
1228 fprintf(f, "%*sreference to: %s\n", depth*4, "", name);
1233 fprintf(f,"%stalloc report on '%s' (total %6lu bytes in %3lu blocks)\n",
1234 (max_depth < 0 ? "full " :""), name,
1235 (unsigned long)talloc_total_size(ptr),
1236 (unsigned long)talloc_total_blocks(ptr));
1240 fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d) %p\n",
1243 (unsigned long)talloc_total_size(ptr),
1244 (unsigned long)talloc_total_blocks(ptr),
1245 (int)talloc_reference_count(ptr), ptr);
1248 fprintf(f, "content: ");
1249 if (talloc_total_size(ptr)) {
1250 int tot = talloc_total_size(ptr);
1253 for (i = 0; i < tot; i++) {
1254 if ((((char *)ptr)[i] > 31) && (((char *)ptr)[i] < 126)) {
1255 fprintf(f, "%c", ((char *)ptr)[i]);
1257 fprintf(f, "~%02x", ((char *)ptr)[i]);
1266 report on memory usage by all children of a pointer, giving a full tree view
1268 void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f)
1270 talloc_report_depth_cb(ptr, depth, max_depth, talloc_report_depth_FILE_helper, f);
1275 report on memory usage by all children of a pointer, giving a full tree view
1277 void talloc_report_full(const void *ptr, FILE *f)
1279 talloc_report_depth_file(ptr, 0, -1, f);
1283 report on memory usage by all children of a pointer
1285 void talloc_report(const void *ptr, FILE *f)
1287 talloc_report_depth_file(ptr, 0, 1, f);
1291 report on any memory hanging off the null context
1293 static void talloc_report_null(void)
1295 if (talloc_total_size(null_context) != 0) {
1296 talloc_report(null_context, stderr);
1301 report on any memory hanging off the null context
1303 static void talloc_report_null_full(void)
1305 if (talloc_total_size(null_context) != 0) {
1306 talloc_report_full(null_context, stderr);
1311 enable tracking of the NULL context
1313 void talloc_enable_null_tracking(void)
1315 if (null_context == NULL) {
1316 null_context = _talloc_named_const(NULL, 0, "null_context");
1321 disable tracking of the NULL context
1323 void talloc_disable_null_tracking(void)
1325 _talloc_free(null_context);
1326 null_context = NULL;
1330 enable leak reporting on exit
1332 void talloc_enable_leak_report(void)
1334 talloc_enable_null_tracking();
1335 atexit(talloc_report_null);
1339 enable full leak reporting on exit
1341 void talloc_enable_leak_report_full(void)
1343 talloc_enable_null_tracking();
1344 atexit(talloc_report_null_full);
1348 talloc and zero memory.
1350 void *_talloc_zero(const void *ctx, size_t size, const char *name)
1352 void *p = _talloc_named_const(ctx, size, name);
1355 memset(p, '\0', size);
1362 memdup with a talloc.
1364 void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
1366 void *newp = _talloc_named_const(t, size, name);
1369 memcpy(newp, p, size);
1375 static inline char *__talloc_strlendup(const void *t, const char *p, size_t len)
1379 ret = (char *)__talloc(t, len + 1);
1380 if (unlikely(!ret)) return NULL;
1382 memcpy(ret, p, len);
1385 _talloc_set_name_const(ret, ret);
1390 strdup with a talloc
1392 char *talloc_strdup(const void *t, const char *p)
1394 if (unlikely(!p)) return NULL;
1395 return __talloc_strlendup(t, p, strlen(p));
1399 strndup with a talloc
1401 char *talloc_strndup(const void *t, const char *p, size_t n)
1403 if (unlikely(!p)) return NULL;
1404 return __talloc_strlendup(t, p, strnlen(p, n));
1407 static inline char *__talloc_strlendup_append(char *s, size_t slen,
1408 const char *a, size_t alen)
1412 ret = talloc_realloc(NULL, s, char, slen + alen + 1);
1413 if (unlikely(!ret)) return NULL;
1415 /* append the string and the trailing \0 */
1416 memcpy(&ret[slen], a, alen);
1419 _talloc_set_name_const(ret, ret);
1424 * Appends at the end of the string.
1426 char *talloc_strdup_append(char *s, const char *a)
1429 return talloc_strdup(NULL, a);
1436 return __talloc_strlendup_append(s, strlen(s), a, strlen(a));
1440 * Appends at the end of the talloc'ed buffer,
1441 * not the end of the string.
1443 char *talloc_strdup_append_buffer(char *s, const char *a)
1448 return talloc_strdup(NULL, a);
1455 slen = talloc_get_size(s);
1456 if (likely(slen > 0)) {
1460 return __talloc_strlendup_append(s, slen, a, strlen(a));
1464 * Appends at the end of the string.
1466 char *talloc_strndup_append(char *s, const char *a, size_t n)
1469 return talloc_strdup(NULL, a);
1476 return __talloc_strlendup_append(s, strlen(s), a, strnlen(a, n));
1480 * Appends at the end of the talloc'ed buffer,
1481 * not the end of the string.
1483 char *talloc_strndup_append_buffer(char *s, const char *a, size_t n)
1488 return talloc_strdup(NULL, a);
1495 slen = talloc_get_size(s);
1496 if (likely(slen > 0)) {
1500 return __talloc_strlendup_append(s, slen, a, strnlen(a, n));
1503 #ifndef HAVE_VA_COPY
1504 #ifdef HAVE___VA_COPY
1505 #define va_copy(dest, src) __va_copy(dest, src)
1507 #define va_copy(dest, src) (dest) = (src)
1511 char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
1518 /* this call looks strange, but it makes it work on older solaris boxes */
1520 len = vsnprintf(&c, 1, fmt, ap2);
1522 if (unlikely(len < 0)) {
1526 ret = (char *)__talloc(t, len+1);
1527 if (unlikely(!ret)) return NULL;
1530 vsnprintf(ret, len+1, fmt, ap2);
1533 _talloc_set_name_const(ret, ret);
1539 Perform string formatting, and return a pointer to newly allocated
1540 memory holding the result, inside a memory pool.
1542 char *talloc_asprintf(const void *t, const char *fmt, ...)
1548 ret = talloc_vasprintf(t, fmt, ap);
1553 static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
1554 const char *fmt, va_list ap)
1555 PRINTF_ATTRIBUTE(3,0);
1557 static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
1558 const char *fmt, va_list ap)
1565 alen = vsnprintf(&c, 1, fmt, ap2);
1569 /* Either the vsnprintf failed or the format resulted in
1570 * no characters being formatted. In the former case, we
1571 * ought to return NULL, in the latter we ought to return
1572 * the original string. Most current callers of this
1573 * function expect it to never return NULL.
1578 s = talloc_realloc(NULL, s, char, slen + alen + 1);
1579 if (!s) return NULL;
1582 vsnprintf(s + slen, alen + 1, fmt, ap2);
1585 _talloc_set_name_const(s, s);
1590 * Realloc @p s to append the formatted result of @p fmt and @p ap,
1591 * and return @p s, which may have moved. Good for gradually
1592 * accumulating output into a string buffer. Appends at the end
1595 char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
1598 return talloc_vasprintf(NULL, fmt, ap);
1601 return __talloc_vaslenprintf_append(s, strlen(s), fmt, ap);
1605 * Realloc @p s to append the formatted result of @p fmt and @p ap,
1606 * and return @p s, which may have moved. Always appends at the
1607 * end of the talloc'ed buffer, not the end of the string.
1609 char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
1614 return talloc_vasprintf(NULL, fmt, ap);
1617 slen = talloc_get_size(s);
1618 if (likely(slen > 0)) {
1622 return __talloc_vaslenprintf_append(s, slen, fmt, ap);
1626 Realloc @p s to append the formatted result of @p fmt and return @p
1627 s, which may have moved. Good for gradually accumulating output
1628 into a string buffer.
1630 char *talloc_asprintf_append(char *s, const char *fmt, ...)
1635 s = talloc_vasprintf_append(s, fmt, ap);
1641 Realloc @p s to append the formatted result of @p fmt and return @p
1642 s, which may have moved. Good for gradually accumulating output
1645 char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...)
1650 s = talloc_vasprintf_append_buffer(s, fmt, ap);
1656 alloc an array, checking for integer overflow in the array size
1658 void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
1660 if (count >= MAX_TALLOC_SIZE/el_size) {
1663 return _talloc_named_const(ctx, el_size * count, name);
1667 alloc an zero array, checking for integer overflow in the array size
1669 void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
1671 if (count >= MAX_TALLOC_SIZE/el_size) {
1674 return _talloc_zero(ctx, el_size * count, name);
1678 realloc an array, checking for integer overflow in the array size
1680 void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
1682 if (count >= MAX_TALLOC_SIZE/el_size) {
1685 return _talloc_realloc(ctx, ptr, el_size * count, name);
1689 a function version of talloc_realloc(), so it can be passed as a function pointer
1690 to libraries that want a realloc function (a realloc function encapsulates
1691 all the basic capabilities of an allocation library, which is why this is useful)
1693 void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
1695 return _talloc_realloc(context, ptr, size, NULL);
1699 static int talloc_autofree_destructor(void *ptr)
1701 autofree_context = NULL;
1705 static void talloc_autofree(void)
1707 _talloc_free(autofree_context);
1711 return a context which will be auto-freed on exit
1712 this is useful for reducing the noise in leak reports
1714 void *talloc_autofree_context(void)
1716 if (autofree_context == NULL) {
1717 autofree_context = _talloc_named_const(NULL, 0, "autofree_context");
1718 talloc_set_destructor(autofree_context, talloc_autofree_destructor);
1719 atexit(talloc_autofree);
1721 return autofree_context;
1724 size_t talloc_get_size(const void *context)
1726 struct talloc_chunk *tc;
1728 if (context == NULL)
1731 tc = talloc_chunk_from_ptr(context);
1737 find a parent of this context that has the given name, if any
1739 void *talloc_find_parent_byname(const void *context, const char *name)
1741 struct talloc_chunk *tc;
1743 if (context == NULL) {
1747 tc = talloc_chunk_from_ptr(context);
1749 if (tc->name && strcmp(tc->name, name) == 0) {
1750 return TC_PTR_FROM_CHUNK(tc);
1752 while (tc && tc->prev) tc = tc->prev;
1761 show the parentage of a context
1763 void talloc_show_parents(const void *context, FILE *file)
1765 struct talloc_chunk *tc;
1767 if (context == NULL) {
1768 fprintf(file, "talloc no parents for NULL\n");
1772 tc = talloc_chunk_from_ptr(context);
1773 fprintf(file, "talloc parents of '%s'\n", talloc_get_name(context));
1775 fprintf(file, "\t'%s'\n", talloc_get_name(TC_PTR_FROM_CHUNK(tc)));
1776 while (tc && tc->prev) tc = tc->prev;
1785 return 1 if ptr is a parent of context
1787 int talloc_is_parent(const void *context, const void *ptr)
1789 struct talloc_chunk *tc;
1791 if (context == NULL) {
1795 tc = talloc_chunk_from_ptr(context);
1797 if (TC_PTR_FROM_CHUNK(tc) == ptr) return 1;
1798 while (tc && tc->prev) tc = tc->prev;