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
52 #endif /* not _TALLOC_SAMBA3 */
54 /* use this to force every realloc to change the pointer, to stress test
55 code that might not cope */
56 #define ALWAYS_REALLOC 0
59 #define MAX_TALLOC_SIZE 0x10000000
60 #define TALLOC_MAGIC_V1 0xe814ec70
61 #define TALLOC_MAGIC_V2 0xe814ec80
62 #define TALLOC_MAGIC TALLOC_MAGIC_V2
63 #define TALLOC_FLAG_FREE 0x01
64 #define TALLOC_FLAG_LOOP 0x02
65 #define TALLOC_FLAG_POOL 0x04 /* This is a talloc pool */
66 #define TALLOC_FLAG_POOLMEM 0x08 /* This is allocated in a pool */
67 #define TALLOC_MAGIC_REFERENCE ((const char *)1)
69 /* by default we abort when given a bad pointer (such as when talloc_free() is called
70 on a pointer that came from malloc() */
72 #define TALLOC_ABORT(reason) abort()
75 #ifndef discard_const_p
76 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
77 # define discard_const_p(type, ptr) ((type *)((intptr_t)(ptr)))
79 # define discard_const_p(type, ptr) ((type *)(ptr))
83 /* these macros gain us a few percent of speed on gcc */
85 /* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
86 as its first argument */
88 #define likely(x) __builtin_expect(!!(x), 1)
91 #define unlikely(x) __builtin_expect(!!(x), 0)
98 #define unlikely(x) (x)
102 /* this null_context is only used if talloc_enable_leak_report() or
103 talloc_enable_leak_report_full() is called, otherwise it remains
106 static void *null_context
;
107 static void *autofree_context
;
109 struct talloc_reference_handle
{
110 struct talloc_reference_handle
*next
, *prev
;
112 const char *location
;
115 typedef int (*talloc_destructor_t
)(void *);
117 struct talloc_chunk
{
118 struct talloc_chunk
*next
, *prev
;
119 struct talloc_chunk
*parent
, *child
;
120 struct talloc_reference_handle
*refs
;
121 talloc_destructor_t destructor
;
127 * "pool" has dual use:
129 * For the talloc pool itself (i.e. TALLOC_FLAG_POOL is set), "pool"
130 * marks the end of the currently allocated area.
132 * For members of the pool (i.e. TALLOC_FLAG_POOLMEM is set), "pool"
133 * is a pointer to the struct talloc_chunk of the pool that it was
134 * allocated from. This way children can quickly find the pool to chew
140 /* 16 byte alignment seems to keep everyone happy */
141 #define TC_HDR_SIZE ((sizeof(struct talloc_chunk)+15)&~15)
142 #define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
144 static void (*talloc_abort_fn
)(const char *reason
);
146 void talloc_set_abort_fn(void (*abort_fn
)(const char *reason
))
148 talloc_abort_fn
= abort_fn
;
151 static void talloc_abort(const char *reason
)
153 if (!talloc_abort_fn
) {
154 TALLOC_ABORT(reason
);
157 talloc_abort_fn(reason
);
160 static void talloc_abort_magic_v1(void)
162 talloc_abort("Bad talloc magic value - old magic v1 used");
165 static void talloc_abort_double_free(void)
167 talloc_abort("Bad talloc magic value - double free");
170 static void talloc_abort_unknown_value(void)
172 talloc_abort("Bad talloc magic value - unknown value");
175 /* panic if we get a bad magic value */
176 static inline struct talloc_chunk
*talloc_chunk_from_ptr(const void *ptr
)
178 const char *pp
= (const char *)ptr
;
179 struct talloc_chunk
*tc
= discard_const_p(struct talloc_chunk
, pp
- TC_HDR_SIZE
);
180 if (unlikely((tc
->flags
& (TALLOC_FLAG_FREE
| ~0xF)) != TALLOC_MAGIC
)) {
181 if ((tc
->flags
& (~0xF)) == TALLOC_MAGIC_V1
) {
182 talloc_abort_magic_v1();
185 if (tc
->flags
& TALLOC_FLAG_FREE
) {
186 talloc_abort_double_free();
188 talloc_abort_unknown_value();
194 /* hook into the front of the list */
195 #define _TLIST_ADD(list, p) \
199 (p)->next = (p)->prev = NULL; \
201 (list)->prev = (p); \
202 (p)->next = (list); \
208 /* remove an element from a list - element doesn't have to be in list. */
209 #define _TLIST_REMOVE(list, p) \
211 if ((p) == (list)) { \
212 (list) = (p)->next; \
213 if (list) (list)->prev = NULL; \
215 if ((p)->prev) (p)->prev->next = (p)->next; \
216 if ((p)->next) (p)->next->prev = (p)->prev; \
218 if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \
223 return the parent chunk of a pointer
225 static inline struct talloc_chunk
*talloc_parent_chunk(const void *ptr
)
227 struct talloc_chunk
*tc
;
229 if (unlikely(ptr
== NULL
)) {
233 tc
= talloc_chunk_from_ptr(ptr
);
234 while (tc
->prev
) tc
=tc
->prev
;
239 void *talloc_parent(const void *ptr
)
241 struct talloc_chunk
*tc
= talloc_parent_chunk(ptr
);
242 return tc
? TC_PTR_FROM_CHUNK(tc
) : NULL
;
248 const char *talloc_parent_name(const void *ptr
)
250 struct talloc_chunk
*tc
= talloc_parent_chunk(ptr
);
251 return tc
? tc
->name
: NULL
;
255 A pool carries an in-pool object count count in the first 16 bytes.
256 bytes. This is done to support talloc_steal() to a parent outside of the
257 pool. The count includes the pool itself, so a talloc_free() on a pool will
258 only destroy the pool if the count has dropped to zero. A talloc_free() of a
259 pool member will reduce the count, and eventually also call free(3) on the
262 The object count is not put into "struct talloc_chunk" because it is only
263 relevant for talloc pools and the alignment to 16 bytes would increase the
264 memory footprint of each talloc chunk by those 16 bytes.
267 #define TALLOC_POOL_HDR_SIZE 16
269 static unsigned int *talloc_pool_objectcount(struct talloc_chunk
*tc
)
271 return (unsigned int *)((char *)tc
+ sizeof(struct talloc_chunk
));
278 static struct talloc_chunk
*talloc_alloc_pool(struct talloc_chunk
*parent
,
281 struct talloc_chunk
*pool_ctx
= NULL
;
283 struct talloc_chunk
*result
;
286 if (parent
== NULL
) {
290 if (parent
->flags
& TALLOC_FLAG_POOL
) {
293 else if (parent
->flags
& TALLOC_FLAG_POOLMEM
) {
294 pool_ctx
= (struct talloc_chunk
*)parent
->pool
;
297 if (pool_ctx
== NULL
) {
301 space_left
= ((char *)pool_ctx
+ TC_HDR_SIZE
+ pool_ctx
->size
)
302 - ((char *)pool_ctx
->pool
);
305 * Align size to 16 bytes
307 chunk_size
= ((size
+ 15) & ~15);
309 if (space_left
< chunk_size
) {
313 result
= (struct talloc_chunk
*)pool_ctx
->pool
;
315 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
316 VALGRIND_MAKE_MEM_UNDEFINED(result
, size
);
319 pool_ctx
->pool
= (void *)((char *)result
+ chunk_size
);
321 result
->flags
= TALLOC_MAGIC
| TALLOC_FLAG_POOLMEM
;
322 result
->pool
= pool_ctx
;
324 *talloc_pool_objectcount(pool_ctx
) += 1;
330 Allocate a bit of memory as a child of an existing pointer
332 static inline void *__talloc(const void *context
, size_t size
)
334 struct talloc_chunk
*tc
= NULL
;
336 if (unlikely(context
== NULL
)) {
337 context
= null_context
;
340 if (unlikely(size
>= MAX_TALLOC_SIZE
)) {
344 if (context
!= NULL
) {
345 tc
= talloc_alloc_pool(talloc_chunk_from_ptr(context
),
350 tc
= (struct talloc_chunk
*)malloc(TC_HDR_SIZE
+size
);
351 if (unlikely(tc
== NULL
)) return NULL
;
352 tc
->flags
= TALLOC_MAGIC
;
357 tc
->destructor
= NULL
;
362 if (likely(context
)) {
363 struct talloc_chunk
*parent
= talloc_chunk_from_ptr(context
);
366 parent
->child
->parent
= NULL
;
367 tc
->next
= parent
->child
;
376 tc
->next
= tc
->prev
= tc
->parent
= NULL
;
379 return TC_PTR_FROM_CHUNK(tc
);
383 * Create a talloc pool
386 void *talloc_pool(const void *context
, size_t size
)
388 void *result
= __talloc(context
, size
+ TALLOC_POOL_HDR_SIZE
);
389 struct talloc_chunk
*tc
;
391 if (unlikely(result
== NULL
)) {
395 tc
= talloc_chunk_from_ptr(result
);
397 tc
->flags
|= TALLOC_FLAG_POOL
;
398 tc
->pool
= (char *)result
+ TALLOC_POOL_HDR_SIZE
;
400 *talloc_pool_objectcount(tc
) = 1;
402 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
403 VALGRIND_MAKE_MEM_NOACCESS(tc
->pool
, size
);
410 setup a destructor to be called on free of a pointer
411 the destructor should return 0 on success, or -1 on failure.
412 if the destructor fails then the free is failed, and the memory can
413 be continued to be used
415 void _talloc_set_destructor(const void *ptr
, int (*destructor
)(void *))
417 struct talloc_chunk
*tc
= talloc_chunk_from_ptr(ptr
);
418 tc
->destructor
= destructor
;
422 increase the reference count on a piece of memory.
424 int talloc_increase_ref_count(const void *ptr
)
426 if (unlikely(!talloc_reference(null_context
, ptr
))) {
433 helper for talloc_reference()
435 this is referenced by a function pointer and should not be inline
437 static int talloc_reference_destructor(struct talloc_reference_handle
*handle
)
439 struct talloc_chunk
*ptr_tc
= talloc_chunk_from_ptr(handle
->ptr
);
440 _TLIST_REMOVE(ptr_tc
->refs
, handle
);
445 more efficient way to add a name to a pointer - the name must point to a
448 static inline void _talloc_set_name_const(const void *ptr
, const char *name
)
450 struct talloc_chunk
*tc
= talloc_chunk_from_ptr(ptr
);
455 internal talloc_named_const()
457 static inline void *_talloc_named_const(const void *context
, size_t size
, const char *name
)
461 ptr
= __talloc(context
, size
);
462 if (unlikely(ptr
== NULL
)) {
466 _talloc_set_name_const(ptr
, name
);
472 make a secondary reference to a pointer, hanging off the given context.
473 the pointer remains valid until both the original caller and this given
476 the major use for this is when two different structures need to reference the
477 same underlying data, and you want to be able to free the two instances separately,
480 void *_talloc_reference_loc(const void *context
, const void *ptr
, const char *location
)
482 struct talloc_chunk
*tc
;
483 struct talloc_reference_handle
*handle
;
484 if (unlikely(ptr
== NULL
)) return NULL
;
486 tc
= talloc_chunk_from_ptr(ptr
);
487 handle
= (struct talloc_reference_handle
*)_talloc_named_const(context
,
488 sizeof(struct talloc_reference_handle
),
489 TALLOC_MAGIC_REFERENCE
);
490 if (unlikely(handle
== NULL
)) return NULL
;
492 /* note that we hang the destructor off the handle, not the
493 main context as that allows the caller to still setup their
494 own destructor on the context if they want to */
495 talloc_set_destructor(handle
, talloc_reference_destructor
);
496 handle
->ptr
= discard_const_p(void, ptr
);
497 handle
->location
= location
;
498 _TLIST_ADD(tc
->refs
, handle
);
502 static void *_talloc_steal_internal(const void *new_ctx
, const void *ptr
);
505 internal talloc_free call
507 static inline int _talloc_free_internal(void *ptr
)
509 struct talloc_chunk
*tc
;
511 if (unlikely(ptr
== NULL
)) {
515 tc
= talloc_chunk_from_ptr(ptr
);
517 if (unlikely(tc
->refs
)) {
519 /* check this is a reference from a child or grantchild
520 * back to it's parent or grantparent
522 * in that case we need to remove the reference and
523 * call another instance of talloc_free() on the current
526 is_child
= talloc_is_parent(tc
->refs
, ptr
);
527 _talloc_free_internal(tc
->refs
);
529 return _talloc_free_internal(ptr
);
534 if (unlikely(tc
->flags
& TALLOC_FLAG_LOOP
)) {
535 /* we have a free loop - stop looping */
539 if (unlikely(tc
->destructor
)) {
540 talloc_destructor_t d
= tc
->destructor
;
541 if (d
== (talloc_destructor_t
)-1) {
544 tc
->destructor
= (talloc_destructor_t
)-1;
549 tc
->destructor
= NULL
;
553 _TLIST_REMOVE(tc
->parent
->child
, tc
);
554 if (tc
->parent
->child
) {
555 tc
->parent
->child
->parent
= tc
->parent
;
558 if (tc
->prev
) tc
->prev
->next
= tc
->next
;
559 if (tc
->next
) tc
->next
->prev
= tc
->prev
;
562 tc
->flags
|= TALLOC_FLAG_LOOP
;
565 /* we need to work out who will own an abandoned child
566 if it cannot be freed. In priority order, the first
567 choice is owner of any remaining reference to this
568 pointer, the second choice is our parent, and the
569 final choice is the null context. */
570 void *child
= TC_PTR_FROM_CHUNK(tc
->child
);
571 const void *new_parent
= null_context
;
572 if (unlikely(tc
->child
->refs
)) {
573 struct talloc_chunk
*p
= talloc_parent_chunk(tc
->child
->refs
);
574 if (p
) new_parent
= TC_PTR_FROM_CHUNK(p
);
576 if (unlikely(_talloc_free_internal(child
) == -1)) {
577 if (new_parent
== null_context
) {
578 struct talloc_chunk
*p
= talloc_parent_chunk(ptr
);
579 if (p
) new_parent
= TC_PTR_FROM_CHUNK(p
);
581 _talloc_steal_internal(new_parent
, child
);
585 tc
->flags
|= TALLOC_FLAG_FREE
;
587 if (tc
->flags
& (TALLOC_FLAG_POOL
|TALLOC_FLAG_POOLMEM
)) {
588 struct talloc_chunk
*pool
;
589 unsigned int *pool_object_count
;
591 pool
= (tc
->flags
& TALLOC_FLAG_POOL
)
592 ? tc
: (struct talloc_chunk
*)tc
->pool
;
594 pool_object_count
= talloc_pool_objectcount(pool
);
596 if (*pool_object_count
== 0) {
597 talloc_abort("Pool object count zero!");
600 *pool_object_count
-= 1;
602 if (*pool_object_count
== 0) {
613 move a lump of memory from one talloc context to another return the
614 ptr on success, or NULL if it could not be transferred.
615 passing NULL as ptr will always return NULL with no side effects.
617 static void *_talloc_steal_internal(const void *new_ctx
, const void *ptr
)
619 struct talloc_chunk
*tc
, *new_tc
;
621 if (unlikely(!ptr
)) {
625 if (unlikely(new_ctx
== NULL
)) {
626 new_ctx
= null_context
;
629 tc
= talloc_chunk_from_ptr(ptr
);
631 if (unlikely(new_ctx
== NULL
)) {
633 _TLIST_REMOVE(tc
->parent
->child
, tc
);
634 if (tc
->parent
->child
) {
635 tc
->parent
->child
->parent
= tc
->parent
;
638 if (tc
->prev
) tc
->prev
->next
= tc
->next
;
639 if (tc
->next
) tc
->next
->prev
= tc
->prev
;
642 tc
->parent
= tc
->next
= tc
->prev
= NULL
;
643 return discard_const_p(void, ptr
);
646 new_tc
= talloc_chunk_from_ptr(new_ctx
);
648 if (unlikely(tc
== new_tc
|| tc
->parent
== new_tc
)) {
649 return discard_const_p(void, ptr
);
653 _TLIST_REMOVE(tc
->parent
->child
, tc
);
654 if (tc
->parent
->child
) {
655 tc
->parent
->child
->parent
= tc
->parent
;
658 if (tc
->prev
) tc
->prev
->next
= tc
->next
;
659 if (tc
->next
) tc
->next
->prev
= tc
->prev
;
663 if (new_tc
->child
) new_tc
->child
->parent
= NULL
;
664 _TLIST_ADD(new_tc
->child
, tc
);
666 return discard_const_p(void, ptr
);
670 move a lump of memory from one talloc context to another return the
671 ptr on success, or NULL if it could not be transferred.
672 passing NULL as ptr will always return NULL with no side effects.
674 void *_talloc_steal_loc(const void *new_ctx
, const void *ptr
, const char *location
)
676 struct talloc_chunk
*tc
;
678 if (unlikely(ptr
== NULL
)) {
682 tc
= talloc_chunk_from_ptr(ptr
);
684 if (unlikely(tc
->refs
!= NULL
) && talloc_parent(ptr
) != new_ctx
) {
685 struct talloc_reference_handle
*h
;
687 fprintf(stderr
, "ERROR: talloc_steal with references at %s\n", location
);
689 for (h
=tc
->refs
; h
; h
=h
->next
) {
691 fprintf(stderr
, "\treference at %s\n", h
->location
);
697 return _talloc_steal_internal(new_ctx
, ptr
);
701 this is like a talloc_steal(), but you must supply the old
702 parent. This resolves the ambiguity in a talloc_steal() which is
703 called on a context that has more than one parent (via references)
705 The old parent can be either a reference or a parent
707 void *talloc_reparent(const void *old_parent
, const void *new_parent
, const void *ptr
)
709 struct talloc_chunk
*tc
;
710 struct talloc_reference_handle
*h
;
712 if (unlikely(ptr
== NULL
)) {
716 if (old_parent
== talloc_parent(ptr
)) {
717 return _talloc_steal_internal(new_parent
, ptr
);
720 tc
= talloc_chunk_from_ptr(ptr
);
721 for (h
=tc
->refs
;h
;h
=h
->next
) {
722 if (talloc_parent(h
) == old_parent
) {
723 if (_talloc_steal_internal(new_parent
, h
) != h
) {
730 /* it wasn't a parent */
735 remove a secondary reference to a pointer. This undo's what
736 talloc_reference() has done. The context and pointer arguments
737 must match those given to a talloc_reference()
739 static inline int talloc_unreference(const void *context
, const void *ptr
)
741 struct talloc_chunk
*tc
= talloc_chunk_from_ptr(ptr
);
742 struct talloc_reference_handle
*h
;
744 if (unlikely(context
== NULL
)) {
745 context
= null_context
;
748 for (h
=tc
->refs
;h
;h
=h
->next
) {
749 struct talloc_chunk
*p
= talloc_parent_chunk(h
);
751 if (context
== NULL
) break;
752 } else if (TC_PTR_FROM_CHUNK(p
) == context
) {
760 return _talloc_free_internal(h
);
764 remove a specific parent context from a pointer. This is a more
765 controlled varient of talloc_free()
767 int talloc_unlink(const void *context
, void *ptr
)
769 struct talloc_chunk
*tc_p
, *new_p
;
776 if (context
== NULL
) {
777 context
= null_context
;
780 if (talloc_unreference(context
, ptr
) == 0) {
784 if (context
== NULL
) {
785 if (talloc_parent_chunk(ptr
) != NULL
) {
789 if (talloc_chunk_from_ptr(context
) != talloc_parent_chunk(ptr
)) {
794 tc_p
= talloc_chunk_from_ptr(ptr
);
796 if (tc_p
->refs
== NULL
) {
797 return _talloc_free_internal(ptr
);
800 new_p
= talloc_parent_chunk(tc_p
->refs
);
802 new_parent
= TC_PTR_FROM_CHUNK(new_p
);
807 if (talloc_unreference(new_parent
, ptr
) != 0) {
811 _talloc_steal_internal(new_parent
, ptr
);
817 add a name to an existing pointer - va_list version
819 static inline const char *talloc_set_name_v(const void *ptr
, const char *fmt
, va_list ap
) PRINTF_ATTRIBUTE(2,0);
821 static inline const char *talloc_set_name_v(const void *ptr
, const char *fmt
, va_list ap
)
823 struct talloc_chunk
*tc
= talloc_chunk_from_ptr(ptr
);
824 tc
->name
= talloc_vasprintf(ptr
, fmt
, ap
);
825 if (likely(tc
->name
)) {
826 _talloc_set_name_const(tc
->name
, ".name");
832 add a name to an existing pointer
834 const char *talloc_set_name(const void *ptr
, const char *fmt
, ...)
839 name
= talloc_set_name_v(ptr
, fmt
, ap
);
846 create a named talloc pointer. Any talloc pointer can be named, and
847 talloc_named() operates just like talloc() except that it allows you
850 void *talloc_named(const void *context
, size_t size
, const char *fmt
, ...)
856 ptr
= __talloc(context
, size
);
857 if (unlikely(ptr
== NULL
)) return NULL
;
860 name
= talloc_set_name_v(ptr
, fmt
, ap
);
863 if (unlikely(name
== NULL
)) {
864 _talloc_free_internal(ptr
);
872 return the name of a talloc ptr, or "UNNAMED"
874 const char *talloc_get_name(const void *ptr
)
876 struct talloc_chunk
*tc
= talloc_chunk_from_ptr(ptr
);
877 if (unlikely(tc
->name
== TALLOC_MAGIC_REFERENCE
)) {
880 if (likely(tc
->name
)) {
888 check if a pointer has the given name. If it does, return the pointer,
889 otherwise return NULL
891 void *talloc_check_name(const void *ptr
, const char *name
)
894 if (unlikely(ptr
== NULL
)) return NULL
;
895 pname
= talloc_get_name(ptr
);
896 if (likely(pname
== name
|| strcmp(pname
, name
) == 0)) {
897 return discard_const_p(void, ptr
);
902 static void talloc_abort_type_missmatch(const char *location
,
904 const char *expected
)
908 reason
= talloc_asprintf(NULL
,
909 "%s: Type mismatch: name[%s] expected[%s]",
914 reason
= "Type mismatch";
917 talloc_abort(reason
);
920 void *_talloc_get_type_abort(const void *ptr
, const char *name
, const char *location
)
924 if (unlikely(ptr
== NULL
)) {
925 talloc_abort_type_missmatch(location
, NULL
, name
);
929 pname
= talloc_get_name(ptr
);
930 if (likely(pname
== name
|| strcmp(pname
, name
) == 0)) {
931 return discard_const_p(void, ptr
);
934 talloc_abort_type_missmatch(location
, pname
, name
);
939 this is for compatibility with older versions of talloc
941 void *talloc_init(const char *fmt
, ...)
948 * samba3 expects talloc_report_depth_cb(NULL, ...)
949 * reports all talloc'ed memory, so we need to enable
952 talloc_enable_null_tracking();
954 ptr
= __talloc(NULL
, 0);
955 if (unlikely(ptr
== NULL
)) return NULL
;
958 name
= talloc_set_name_v(ptr
, fmt
, ap
);
961 if (unlikely(name
== NULL
)) {
962 _talloc_free_internal(ptr
);
970 this is a replacement for the Samba3 talloc_destroy_pool functionality. It
971 should probably not be used in new code. It's in here to keep the talloc
972 code consistent across Samba 3 and 4.
974 void talloc_free_children(void *ptr
)
976 struct talloc_chunk
*tc
;
978 if (unlikely(ptr
== NULL
)) {
982 tc
= talloc_chunk_from_ptr(ptr
);
985 /* we need to work out who will own an abandoned child
986 if it cannot be freed. In priority order, the first
987 choice is owner of any remaining reference to this
988 pointer, the second choice is our parent, and the
989 final choice is the null context. */
990 void *child
= TC_PTR_FROM_CHUNK(tc
->child
);
991 const void *new_parent
= null_context
;
992 if (unlikely(tc
->child
->refs
)) {
993 struct talloc_chunk
*p
= talloc_parent_chunk(tc
->child
->refs
);
994 if (p
) new_parent
= TC_PTR_FROM_CHUNK(p
);
996 if (unlikely(talloc_free(child
) == -1)) {
997 if (new_parent
== null_context
) {
998 struct talloc_chunk
*p
= talloc_parent_chunk(ptr
);
999 if (p
) new_parent
= TC_PTR_FROM_CHUNK(p
);
1001 _talloc_steal_internal(new_parent
, child
);
1005 if ((tc
->flags
& TALLOC_FLAG_POOL
)
1006 && (*talloc_pool_objectcount(tc
) == 1)) {
1007 tc
->pool
= ((char *)tc
+ TC_HDR_SIZE
+ TALLOC_POOL_HDR_SIZE
);
1008 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
1009 VALGRIND_MAKE_MEM_NOACCESS(
1010 tc
->pool
, tc
->size
- TALLOC_POOL_HDR_SIZE
);
1016 Allocate a bit of memory as a child of an existing pointer
1018 void *_talloc(const void *context
, size_t size
)
1020 return __talloc(context
, size
);
1024 externally callable talloc_set_name_const()
1026 void talloc_set_name_const(const void *ptr
, const char *name
)
1028 _talloc_set_name_const(ptr
, name
);
1032 create a named talloc pointer. Any talloc pointer can be named, and
1033 talloc_named() operates just like talloc() except that it allows you
1034 to name the pointer.
1036 void *talloc_named_const(const void *context
, size_t size
, const char *name
)
1038 return _talloc_named_const(context
, size
, name
);
1042 free a talloc pointer. This also frees all child pointers of this
1045 return 0 if the memory is actually freed, otherwise -1. The memory
1046 will not be freed if the ref_count is > 1 or the destructor (if
1047 any) returns non-zero
1049 int _talloc_free(void *ptr
, const char *location
)
1051 struct talloc_chunk
*tc
;
1053 if (unlikely(ptr
== NULL
)) {
1057 tc
= talloc_chunk_from_ptr(ptr
);
1059 if (unlikely(tc
->refs
!= NULL
)) {
1060 struct talloc_reference_handle
*h
;
1062 fprintf(stderr
, "ERROR: talloc_free with references at %s\n", location
);
1064 for (h
=tc
->refs
; h
; h
=h
->next
) {
1066 fprintf(stderr
, "\treference at %s\n", h
->location
);
1072 return _talloc_free_internal(ptr
);
1078 A talloc version of realloc. The context argument is only used if
1081 void *_talloc_realloc(const void *context
, void *ptr
, size_t size
, const char *name
)
1083 struct talloc_chunk
*tc
;
1085 bool malloced
= false;
1087 /* size zero is equivalent to free() */
1088 if (unlikely(size
== 0)) {
1089 talloc_unlink(context
, ptr
);
1093 if (unlikely(size
>= MAX_TALLOC_SIZE
)) {
1097 /* realloc(NULL) is equivalent to malloc() */
1099 return _talloc_named_const(context
, size
, name
);
1102 tc
= talloc_chunk_from_ptr(ptr
);
1104 /* don't allow realloc on referenced pointers */
1105 if (unlikely(tc
->refs
)) {
1109 /* don't let anybody try to realloc a talloc_pool */
1110 if (unlikely(tc
->flags
& TALLOC_FLAG_POOL
)) {
1114 /* don't shrink if we have less than 1k to gain */
1115 if ((size
< tc
->size
) && ((tc
->size
- size
) < 1024)) {
1120 /* by resetting magic we catch users of the old memory */
1121 tc
->flags
|= TALLOC_FLAG_FREE
;
1124 new_ptr
= malloc(size
+ TC_HDR_SIZE
);
1126 memcpy(new_ptr
, tc
, tc
->size
+ TC_HDR_SIZE
);
1130 if (tc
->flags
& TALLOC_FLAG_POOLMEM
) {
1132 new_ptr
= talloc_alloc_pool(tc
, size
+ TC_HDR_SIZE
);
1133 *talloc_pool_objectcount((struct talloc_chunk
*)
1136 if (new_ptr
== NULL
) {
1137 new_ptr
= malloc(TC_HDR_SIZE
+size
);
1142 memcpy(new_ptr
, tc
, MIN(tc
->size
,size
) + TC_HDR_SIZE
);
1146 new_ptr
= realloc(tc
, size
+ TC_HDR_SIZE
);
1149 if (unlikely(!new_ptr
)) {
1150 tc
->flags
&= ~TALLOC_FLAG_FREE
;
1154 tc
= (struct talloc_chunk
*)new_ptr
;
1155 tc
->flags
&= ~TALLOC_FLAG_FREE
;
1157 tc
->flags
&= ~TALLOC_FLAG_POOLMEM
;
1160 tc
->parent
->child
= tc
;
1163 tc
->child
->parent
= tc
;
1167 tc
->prev
->next
= tc
;
1170 tc
->next
->prev
= tc
;
1174 _talloc_set_name_const(TC_PTR_FROM_CHUNK(tc
), name
);
1176 return TC_PTR_FROM_CHUNK(tc
);
1180 a wrapper around talloc_steal() for situations where you are moving a pointer
1181 between two structures, and want the old pointer to be set to NULL
1183 void *_talloc_move(const void *new_ctx
, const void *_pptr
)
1185 const void **pptr
= discard_const_p(const void *,_pptr
);
1186 void *ret
= talloc_steal(new_ctx
, (void *)*pptr
);
1192 return the total size of a talloc pool (subtree)
1194 size_t talloc_total_size(const void *ptr
)
1197 struct talloc_chunk
*c
, *tc
;
1206 tc
= talloc_chunk_from_ptr(ptr
);
1208 if (tc
->flags
& TALLOC_FLAG_LOOP
) {
1212 tc
->flags
|= TALLOC_FLAG_LOOP
;
1215 for (c
=tc
->child
;c
;c
=c
->next
) {
1216 total
+= talloc_total_size(TC_PTR_FROM_CHUNK(c
));
1219 tc
->flags
&= ~TALLOC_FLAG_LOOP
;
1225 return the total number of blocks in a talloc pool (subtree)
1227 size_t talloc_total_blocks(const void *ptr
)
1230 struct talloc_chunk
*c
, *tc
= talloc_chunk_from_ptr(ptr
);
1232 if (tc
->flags
& TALLOC_FLAG_LOOP
) {
1236 tc
->flags
|= TALLOC_FLAG_LOOP
;
1239 for (c
=tc
->child
;c
;c
=c
->next
) {
1240 total
+= talloc_total_blocks(TC_PTR_FROM_CHUNK(c
));
1243 tc
->flags
&= ~TALLOC_FLAG_LOOP
;
1249 return the number of external references to a pointer
1251 size_t talloc_reference_count(const void *ptr
)
1253 struct talloc_chunk
*tc
= talloc_chunk_from_ptr(ptr
);
1254 struct talloc_reference_handle
*h
;
1257 for (h
=tc
->refs
;h
;h
=h
->next
) {
1264 report on memory usage by all children of a pointer, giving a full tree view
1266 void talloc_report_depth_cb(const void *ptr
, int depth
, int max_depth
,
1267 void (*callback
)(const void *ptr
,
1268 int depth
, int max_depth
,
1270 void *private_data
),
1273 struct talloc_chunk
*c
, *tc
;
1278 if (ptr
== NULL
) return;
1280 tc
= talloc_chunk_from_ptr(ptr
);
1282 if (tc
->flags
& TALLOC_FLAG_LOOP
) {
1286 callback(ptr
, depth
, max_depth
, 0, private_data
);
1288 if (max_depth
>= 0 && depth
>= max_depth
) {
1292 tc
->flags
|= TALLOC_FLAG_LOOP
;
1293 for (c
=tc
->child
;c
;c
=c
->next
) {
1294 if (c
->name
== TALLOC_MAGIC_REFERENCE
) {
1295 struct talloc_reference_handle
*h
= (struct talloc_reference_handle
*)TC_PTR_FROM_CHUNK(c
);
1296 callback(h
->ptr
, depth
+ 1, max_depth
, 1, private_data
);
1298 talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c
), depth
+ 1, max_depth
, callback
, private_data
);
1301 tc
->flags
&= ~TALLOC_FLAG_LOOP
;
1304 static void talloc_report_depth_FILE_helper(const void *ptr
, int depth
, int max_depth
, int is_ref
, void *_f
)
1306 const char *name
= talloc_get_name(ptr
);
1307 FILE *f
= (FILE *)_f
;
1310 fprintf(f
, "%*sreference to: %s\n", depth
*4, "", name
);
1315 fprintf(f
,"%stalloc report on '%s' (total %6lu bytes in %3lu blocks)\n",
1316 (max_depth
< 0 ? "full " :""), name
,
1317 (unsigned long)talloc_total_size(ptr
),
1318 (unsigned long)talloc_total_blocks(ptr
));
1322 fprintf(f
, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d) %p\n",
1325 (unsigned long)talloc_total_size(ptr
),
1326 (unsigned long)talloc_total_blocks(ptr
),
1327 (int)talloc_reference_count(ptr
), ptr
);
1330 fprintf(f
, "content: ");
1331 if (talloc_total_size(ptr
)) {
1332 int tot
= talloc_total_size(ptr
);
1335 for (i
= 0; i
< tot
; i
++) {
1336 if ((((char *)ptr
)[i
] > 31) && (((char *)ptr
)[i
] < 126)) {
1337 fprintf(f
, "%c", ((char *)ptr
)[i
]);
1339 fprintf(f
, "~%02x", ((char *)ptr
)[i
]);
1348 report on memory usage by all children of a pointer, giving a full tree view
1350 void talloc_report_depth_file(const void *ptr
, int depth
, int max_depth
, FILE *f
)
1352 talloc_report_depth_cb(ptr
, depth
, max_depth
, talloc_report_depth_FILE_helper
, f
);
1357 report on memory usage by all children of a pointer, giving a full tree view
1359 void talloc_report_full(const void *ptr
, FILE *f
)
1361 talloc_report_depth_file(ptr
, 0, -1, f
);
1365 report on memory usage by all children of a pointer
1367 void talloc_report(const void *ptr
, FILE *f
)
1369 talloc_report_depth_file(ptr
, 0, 1, f
);
1373 report on any memory hanging off the null context
1375 static void talloc_report_null(void)
1377 if (talloc_total_size(null_context
) != 0) {
1378 talloc_report(null_context
, stderr
);
1383 report on any memory hanging off the null context
1385 static void talloc_report_null_full(void)
1387 if (talloc_total_size(null_context
) != 0) {
1388 talloc_report_full(null_context
, stderr
);
1393 enable tracking of the NULL context
1395 void talloc_enable_null_tracking(void)
1397 if (null_context
== NULL
) {
1398 null_context
= _talloc_named_const(NULL
, 0, "null_context");
1403 disable tracking of the NULL context
1405 void talloc_disable_null_tracking(void)
1407 talloc_free(null_context
);
1408 null_context
= NULL
;
1412 enable leak reporting on exit
1414 void talloc_enable_leak_report(void)
1416 talloc_enable_null_tracking();
1417 atexit(talloc_report_null
);
1421 enable full leak reporting on exit
1423 void talloc_enable_leak_report_full(void)
1425 talloc_enable_null_tracking();
1426 atexit(talloc_report_null_full
);
1430 talloc and zero memory.
1432 void *_talloc_zero(const void *ctx
, size_t size
, const char *name
)
1434 void *p
= _talloc_named_const(ctx
, size
, name
);
1437 memset(p
, '\0', size
);
1444 memdup with a talloc.
1446 void *_talloc_memdup(const void *t
, const void *p
, size_t size
, const char *name
)
1448 void *newp
= _talloc_named_const(t
, size
, name
);
1451 memcpy(newp
, p
, size
);
1457 static inline char *__talloc_strlendup(const void *t
, const char *p
, size_t len
)
1461 ret
= (char *)__talloc(t
, len
+ 1);
1462 if (unlikely(!ret
)) return NULL
;
1464 memcpy(ret
, p
, len
);
1467 _talloc_set_name_const(ret
, ret
);
1472 strdup with a talloc
1474 char *talloc_strdup(const void *t
, const char *p
)
1476 if (unlikely(!p
)) return NULL
;
1477 return __talloc_strlendup(t
, p
, strlen(p
));
1481 strndup with a talloc
1483 char *talloc_strndup(const void *t
, const char *p
, size_t n
)
1485 if (unlikely(!p
)) return NULL
;
1486 return __talloc_strlendup(t
, p
, strnlen(p
, n
));
1489 static inline char *__talloc_strlendup_append(char *s
, size_t slen
,
1490 const char *a
, size_t alen
)
1494 ret
= talloc_realloc(NULL
, s
, char, slen
+ alen
+ 1);
1495 if (unlikely(!ret
)) return NULL
;
1497 /* append the string and the trailing \0 */
1498 memcpy(&ret
[slen
], a
, alen
);
1501 _talloc_set_name_const(ret
, ret
);
1506 * Appends at the end of the string.
1508 char *talloc_strdup_append(char *s
, const char *a
)
1511 return talloc_strdup(NULL
, a
);
1518 return __talloc_strlendup_append(s
, strlen(s
), a
, strlen(a
));
1522 * Appends at the end of the talloc'ed buffer,
1523 * not the end of the string.
1525 char *talloc_strdup_append_buffer(char *s
, const char *a
)
1530 return talloc_strdup(NULL
, a
);
1537 slen
= talloc_get_size(s
);
1538 if (likely(slen
> 0)) {
1542 return __talloc_strlendup_append(s
, slen
, a
, strlen(a
));
1546 * Appends at the end of the string.
1548 char *talloc_strndup_append(char *s
, const char *a
, size_t n
)
1551 return talloc_strdup(NULL
, a
);
1558 return __talloc_strlendup_append(s
, strlen(s
), a
, strnlen(a
, n
));
1562 * Appends at the end of the talloc'ed buffer,
1563 * not the end of the string.
1565 char *talloc_strndup_append_buffer(char *s
, const char *a
, size_t n
)
1570 return talloc_strdup(NULL
, a
);
1577 slen
= talloc_get_size(s
);
1578 if (likely(slen
> 0)) {
1582 return __talloc_strlendup_append(s
, slen
, a
, strnlen(a
, n
));
1585 #ifndef HAVE_VA_COPY
1586 #ifdef HAVE___VA_COPY
1587 #define va_copy(dest, src) __va_copy(dest, src)
1589 #define va_copy(dest, src) (dest) = (src)
1593 char *talloc_vasprintf(const void *t
, const char *fmt
, va_list ap
)
1600 /* this call looks strange, but it makes it work on older solaris boxes */
1602 len
= vsnprintf(&c
, 1, fmt
, ap2
);
1604 if (unlikely(len
< 0)) {
1608 ret
= (char *)__talloc(t
, len
+1);
1609 if (unlikely(!ret
)) return NULL
;
1612 vsnprintf(ret
, len
+1, fmt
, ap2
);
1615 _talloc_set_name_const(ret
, ret
);
1621 Perform string formatting, and return a pointer to newly allocated
1622 memory holding the result, inside a memory pool.
1624 char *talloc_asprintf(const void *t
, const char *fmt
, ...)
1630 ret
= talloc_vasprintf(t
, fmt
, ap
);
1635 static inline char *__talloc_vaslenprintf_append(char *s
, size_t slen
,
1636 const char *fmt
, va_list ap
)
1637 PRINTF_ATTRIBUTE(3,0);
1639 static inline char *__talloc_vaslenprintf_append(char *s
, size_t slen
,
1640 const char *fmt
, va_list ap
)
1647 alen
= vsnprintf(&c
, 1, fmt
, ap2
);
1651 /* Either the vsnprintf failed or the format resulted in
1652 * no characters being formatted. In the former case, we
1653 * ought to return NULL, in the latter we ought to return
1654 * the original string. Most current callers of this
1655 * function expect it to never return NULL.
1660 s
= talloc_realloc(NULL
, s
, char, slen
+ alen
+ 1);
1661 if (!s
) return NULL
;
1664 vsnprintf(s
+ slen
, alen
+ 1, fmt
, ap2
);
1667 _talloc_set_name_const(s
, s
);
1672 * Realloc @p s to append the formatted result of @p fmt and @p ap,
1673 * and return @p s, which may have moved. Good for gradually
1674 * accumulating output into a string buffer. Appends at the end
1677 char *talloc_vasprintf_append(char *s
, const char *fmt
, va_list ap
)
1680 return talloc_vasprintf(NULL
, fmt
, ap
);
1683 return __talloc_vaslenprintf_append(s
, strlen(s
), fmt
, ap
);
1687 * Realloc @p s to append the formatted result of @p fmt and @p ap,
1688 * and return @p s, which may have moved. Always appends at the
1689 * end of the talloc'ed buffer, not the end of the string.
1691 char *talloc_vasprintf_append_buffer(char *s
, const char *fmt
, va_list ap
)
1696 return talloc_vasprintf(NULL
, fmt
, ap
);
1699 slen
= talloc_get_size(s
);
1700 if (likely(slen
> 0)) {
1704 return __talloc_vaslenprintf_append(s
, slen
, fmt
, ap
);
1708 Realloc @p s to append the formatted result of @p fmt and return @p
1709 s, which may have moved. Good for gradually accumulating output
1710 into a string buffer.
1712 char *talloc_asprintf_append(char *s
, const char *fmt
, ...)
1717 s
= talloc_vasprintf_append(s
, fmt
, ap
);
1723 Realloc @p s to append the formatted result of @p fmt and return @p
1724 s, which may have moved. Good for gradually accumulating output
1727 char *talloc_asprintf_append_buffer(char *s
, const char *fmt
, ...)
1732 s
= talloc_vasprintf_append_buffer(s
, fmt
, ap
);
1738 alloc an array, checking for integer overflow in the array size
1740 void *_talloc_array(const void *ctx
, size_t el_size
, unsigned count
, const char *name
)
1742 if (count
>= MAX_TALLOC_SIZE
/el_size
) {
1745 return _talloc_named_const(ctx
, el_size
* count
, name
);
1749 alloc an zero array, checking for integer overflow in the array size
1751 void *_talloc_zero_array(const void *ctx
, size_t el_size
, unsigned count
, const char *name
)
1753 if (count
>= MAX_TALLOC_SIZE
/el_size
) {
1756 return _talloc_zero(ctx
, el_size
* count
, name
);
1760 realloc an array, checking for integer overflow in the array size
1762 void *_talloc_realloc_array(const void *ctx
, void *ptr
, size_t el_size
, unsigned count
, const char *name
)
1764 if (count
>= MAX_TALLOC_SIZE
/el_size
) {
1767 return _talloc_realloc(ctx
, ptr
, el_size
* count
, name
);
1771 a function version of talloc_realloc(), so it can be passed as a function pointer
1772 to libraries that want a realloc function (a realloc function encapsulates
1773 all the basic capabilities of an allocation library, which is why this is useful)
1775 void *talloc_realloc_fn(const void *context
, void *ptr
, size_t size
)
1777 return _talloc_realloc(context
, ptr
, size
, NULL
);
1781 static int talloc_autofree_destructor(void *ptr
)
1783 autofree_context
= NULL
;
1787 static void talloc_autofree(void)
1789 talloc_free(autofree_context
);
1793 return a context which will be auto-freed on exit
1794 this is useful for reducing the noise in leak reports
1796 void *talloc_autofree_context(void)
1798 if (autofree_context
== NULL
) {
1799 autofree_context
= _talloc_named_const(NULL
, 0, "autofree_context");
1800 talloc_set_destructor(autofree_context
, talloc_autofree_destructor
);
1801 atexit(talloc_autofree
);
1803 return autofree_context
;
1806 size_t talloc_get_size(const void *context
)
1808 struct talloc_chunk
*tc
;
1810 if (context
== NULL
)
1813 tc
= talloc_chunk_from_ptr(context
);
1819 find a parent of this context that has the given name, if any
1821 void *talloc_find_parent_byname(const void *context
, const char *name
)
1823 struct talloc_chunk
*tc
;
1825 if (context
== NULL
) {
1829 tc
= talloc_chunk_from_ptr(context
);
1831 if (tc
->name
&& strcmp(tc
->name
, name
) == 0) {
1832 return TC_PTR_FROM_CHUNK(tc
);
1834 while (tc
&& tc
->prev
) tc
= tc
->prev
;
1843 show the parentage of a context
1845 void talloc_show_parents(const void *context
, FILE *file
)
1847 struct talloc_chunk
*tc
;
1849 if (context
== NULL
) {
1850 fprintf(file
, "talloc no parents for NULL\n");
1854 tc
= talloc_chunk_from_ptr(context
);
1855 fprintf(file
, "talloc parents of '%s'\n", talloc_get_name(context
));
1857 fprintf(file
, "\t'%s'\n", talloc_get_name(TC_PTR_FROM_CHUNK(tc
)));
1858 while (tc
&& tc
->prev
) tc
= tc
->prev
;
1867 return 1 if ptr is a parent of context
1869 int talloc_is_parent(const void *context
, const void *ptr
)
1871 struct talloc_chunk
*tc
;
1873 if (context
== NULL
) {
1877 tc
= talloc_chunk_from_ptr(context
);
1879 if (TC_PTR_FROM_CHUNK(tc
) == ptr
) return 1;
1880 while (tc
&& tc
->prev
) tc
= tc
->prev
;
1891 /* ABI compat functions (do NOT append anything beyond thess functions,
1892 * keep them as the last ones in the file) */
1894 static const char *talloc_ABI_compat_location
= "Called from compatibility function";
1896 /* ABI compat function (don't use) */
1897 void *_talloc_reference(const void *context
, const void *ptr
) {
1898 return _talloc_reference_loc(context
, ptr
, talloc_ABI_compat_location
);
1901 /* ABI compat function (don't use) */
1902 void *_talloc_steal(const void *new_ctx
, const void *ptr
)
1904 return _talloc_steal_internal(new_ctx
, ptr
);
1908 int talloc_free(void *ptr
);
1909 int talloc_free(void *ptr
)
1911 return _talloc_free_internal(ptr
);
1914 /* DO NOT APPEND ANYTHING BEYOND THIS POINT */