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 */
75 #define TALLOC_MAGIC_REFERENCE ((const char *)1)
77 /* by default we abort when given a bad pointer (such as when talloc_free() is called
78 on a pointer that came from malloc() */
80 #define TALLOC_ABORT(reason) abort()
83 #ifndef discard_const_p
84 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
85 # define discard_const_p(type, ptr) ((type *)((intptr_t)(ptr)))
87 # define discard_const_p(type, ptr) ((type *)(ptr))
91 /* these macros gain us a few percent of speed on gcc */
93 /* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
94 as its first argument */
96 #define likely(x) __builtin_expect(!!(x), 1)
99 #define unlikely(x) __builtin_expect(!!(x), 0)
103 #define likely(x) (x)
106 #define unlikely(x) (x)
110 /* this null_context is only used if talloc_enable_leak_report() or
111 talloc_enable_leak_report_full() is called, otherwise it remains
114 static void *null_context;
115 static void *autofree_context;
117 /* used to enable fill of memory on free, which can be useful for
118 * catching use after free errors when valgrind is too slow
126 #define TALLOC_FILL_ENV "TALLOC_FREE_FILL"
129 * do not wipe the header, to allow the
130 * double-free logic to still work
132 #define TC_INVALIDATE_FULL_FILL_CHUNK(_tc) do { \
133 if (unlikely(talloc_fill.enabled)) { \
134 size_t _flen = (_tc)->size; \
135 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
136 memset(_fptr, talloc_fill.fill_value, _flen); \
140 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
141 /* Mark the whole chunk as not accessable */
142 #define TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc) do { \
143 size_t _flen = TC_HDR_SIZE + (_tc)->size; \
144 char *_fptr = (char *)(_tc); \
145 VALGRIND_MAKE_MEM_NOACCESS(_fptr, _flen); \
148 #define TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc) do { } while (0)
151 #define TC_INVALIDATE_FULL_CHUNK(_tc) do { \
152 TC_INVALIDATE_FULL_FILL_CHUNK(_tc); \
153 TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc); \
156 #define TC_INVALIDATE_SHRINK_FILL_CHUNK(_tc, _new_size) do { \
157 if (unlikely(talloc_fill.enabled)) { \
158 size_t _flen = (_tc)->size - (_new_size); \
159 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
160 _fptr += (_new_size); \
161 memset(_fptr, talloc_fill.fill_value, _flen); \
165 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
166 /* Mark the unused bytes not accessable */
167 #define TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { \
168 size_t _flen = (_tc)->size - (_new_size); \
169 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
170 _fptr += (_new_size); \
171 VALGRIND_MAKE_MEM_NOACCESS(_fptr, _flen); \
174 #define TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
177 #define TC_INVALIDATE_SHRINK_CHUNK(_tc, _new_size) do { \
178 TC_INVALIDATE_SHRINK_FILL_CHUNK(_tc, _new_size); \
179 TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size); \
182 #define TC_UNDEFINE_SHRINK_FILL_CHUNK(_tc, _new_size) do { \
183 if (unlikely(talloc_fill.enabled)) { \
184 size_t _flen = (_tc)->size - (_new_size); \
185 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
186 _fptr += (_new_size); \
187 memset(_fptr, talloc_fill.fill_value, _flen); \
191 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
192 /* Mark the unused bytes as undefined */
193 #define TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { \
194 size_t _flen = (_tc)->size - (_new_size); \
195 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
196 _fptr += (_new_size); \
197 VALGRIND_MAKE_MEM_UNDEFINED(_fptr, _flen); \
200 #define TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
203 #define TC_UNDEFINE_SHRINK_CHUNK(_tc, _new_size) do { \
204 TC_UNDEFINE_SHRINK_FILL_CHUNK(_tc, _new_size); \
205 TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size); \
208 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
209 /* Mark the new bytes as undefined */
210 #define TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size) do { \
211 size_t _old_used = TC_HDR_SIZE + (_tc)->size; \
212 size_t _new_used = TC_HDR_SIZE + (_new_size); \
213 size_t _flen = _new_used - _old_used; \
214 char *_fptr = _old_used + (char *)(_tc); \
215 VALGRIND_MAKE_MEM_UNDEFINED(_fptr, _flen); \
218 #define TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
221 #define TC_UNDEFINE_GROW_CHUNK(_tc, _new_size) do { \
222 TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size); \
225 struct talloc_reference_handle {
226 struct talloc_reference_handle *next, *prev;
228 const char *location;
231 struct talloc_memlimit {
232 struct talloc_chunk *parent;
233 struct talloc_memlimit *upper;
238 static inline bool talloc_memlimit_check(struct talloc_memlimit *limit, size_t size);
239 static inline void talloc_memlimit_grow(struct talloc_memlimit *limit,
241 static inline void talloc_memlimit_shrink(struct talloc_memlimit *limit,
243 static inline void talloc_memlimit_update_on_free(struct talloc_chunk *tc);
245 static inline void _talloc_set_name_const(const void *ptr, const char *name);
247 typedef int (*talloc_destructor_t)(void *);
249 struct talloc_pool_hdr;
251 struct talloc_chunk {
252 struct talloc_chunk *next, *prev;
253 struct talloc_chunk *parent, *child;
254 struct talloc_reference_handle *refs;
255 talloc_destructor_t destructor;
262 * if 'limit' is set it means all *new* children of the context will
263 * be limited to a total aggregate size ox max_size for memory
265 * cur_size is used to keep track of the current use
267 struct talloc_memlimit *limit;
270 * For members of a pool (i.e. TALLOC_FLAG_POOLMEM is set), "pool"
271 * is a pointer to the struct talloc_chunk of the pool that it was
272 * allocated from. This way children can quickly find the pool to chew
275 struct talloc_pool_hdr *pool;
278 /* 16 byte alignment seems to keep everyone happy */
279 #define TC_ALIGN16(s) (((s)+15)&~15)
280 #define TC_HDR_SIZE TC_ALIGN16(sizeof(struct talloc_chunk))
281 #define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
283 _PUBLIC_ int talloc_version_major(void)
285 return TALLOC_VERSION_MAJOR;
288 _PUBLIC_ int talloc_version_minor(void)
290 return TALLOC_VERSION_MINOR;
293 static void (*talloc_log_fn)(const char *message);
295 _PUBLIC_ void talloc_set_log_fn(void (*log_fn)(const char *message))
297 talloc_log_fn = log_fn;
300 static void talloc_log(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);
301 static void talloc_log(const char *fmt, ...)
306 if (!talloc_log_fn) {
311 message = talloc_vasprintf(NULL, fmt, ap);
314 talloc_log_fn(message);
315 talloc_free(message);
318 static void talloc_log_stderr(const char *message)
320 fprintf(stderr, "%s", message);
323 _PUBLIC_ void talloc_set_log_stderr(void)
325 talloc_set_log_fn(talloc_log_stderr);
328 static void (*talloc_abort_fn)(const char *reason);
330 _PUBLIC_ void talloc_set_abort_fn(void (*abort_fn)(const char *reason))
332 talloc_abort_fn = abort_fn;
335 static void talloc_abort(const char *reason)
337 talloc_log("%s\n", reason);
339 if (!talloc_abort_fn) {
340 TALLOC_ABORT(reason);
343 talloc_abort_fn(reason);
346 static void talloc_abort_magic(unsigned magic)
348 unsigned striped = magic - TALLOC_MAGIC_BASE;
349 unsigned major = (striped & 0xFFFFF000) >> 12;
350 unsigned minor = (striped & 0x00000FF0) >> 4;
351 talloc_log("Bad talloc magic[0x%08X/%u/%u] expected[0x%08X/%u/%u]\n",
353 TALLOC_MAGIC, TALLOC_VERSION_MAJOR, TALLOC_VERSION_MINOR);
354 talloc_abort("Bad talloc magic value - wrong talloc version used/mixed");
357 static void talloc_abort_access_after_free(void)
359 talloc_abort("Bad talloc magic value - access after free");
362 static void talloc_abort_unknown_value(void)
364 talloc_abort("Bad talloc magic value - unknown value");
367 /* panic if we get a bad magic value */
368 static inline struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
370 const char *pp = (const char *)ptr;
371 struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp - TC_HDR_SIZE);
372 if (unlikely((tc->flags & (TALLOC_FLAG_FREE | ~0xF)) != TALLOC_MAGIC)) {
373 if ((tc->flags & (~0xFFF)) == TALLOC_MAGIC_BASE) {
374 talloc_abort_magic(tc->flags & (~0xF));
378 if (tc->flags & TALLOC_FLAG_FREE) {
379 talloc_log("talloc: access after free error - first free may be at %s\n", tc->name);
380 talloc_abort_access_after_free();
383 talloc_abort_unknown_value();
390 /* hook into the front of the list */
391 #define _TLIST_ADD(list, p) \
395 (p)->next = (p)->prev = NULL; \
397 (list)->prev = (p); \
398 (p)->next = (list); \
404 /* remove an element from a list - element doesn't have to be in list. */
405 #define _TLIST_REMOVE(list, p) \
407 if ((p) == (list)) { \
408 (list) = (p)->next; \
409 if (list) (list)->prev = NULL; \
411 if ((p)->prev) (p)->prev->next = (p)->next; \
412 if ((p)->next) (p)->next->prev = (p)->prev; \
414 if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \
419 return the parent chunk of a pointer
421 static inline struct talloc_chunk *talloc_parent_chunk(const void *ptr)
423 struct talloc_chunk *tc;
425 if (unlikely(ptr == NULL)) {
429 tc = talloc_chunk_from_ptr(ptr);
430 while (tc->prev) tc=tc->prev;
435 _PUBLIC_ void *talloc_parent(const void *ptr)
437 struct talloc_chunk *tc = talloc_parent_chunk(ptr);
438 return tc? TC_PTR_FROM_CHUNK(tc) : NULL;
444 _PUBLIC_ const char *talloc_parent_name(const void *ptr)
446 struct talloc_chunk *tc = talloc_parent_chunk(ptr);
447 return tc? tc->name : NULL;
451 A pool carries an in-pool object count count in the first 16 bytes.
452 bytes. This is done to support talloc_steal() to a parent outside of the
453 pool. The count includes the pool itself, so a talloc_free() on a pool will
454 only destroy the pool if the count has dropped to zero. A talloc_free() of a
455 pool member will reduce the count, and eventually also call free(3) on the
458 The object count is not put into "struct talloc_chunk" because it is only
459 relevant for talloc pools and the alignment to 16 bytes would increase the
460 memory footprint of each talloc chunk by those 16 bytes.
463 struct talloc_pool_hdr {
465 unsigned int object_count;
469 #define TP_HDR_SIZE TC_ALIGN16(sizeof(struct talloc_pool_hdr))
471 static inline struct talloc_pool_hdr *talloc_pool_from_chunk(struct talloc_chunk *c)
473 return (struct talloc_pool_hdr *)((char *)c - TP_HDR_SIZE);
476 static inline struct talloc_chunk *talloc_chunk_from_pool(struct talloc_pool_hdr *h)
478 return (struct talloc_chunk *)((char *)h + TP_HDR_SIZE);
481 static inline void *tc_pool_end(struct talloc_pool_hdr *pool_hdr)
483 struct talloc_chunk *tc = talloc_chunk_from_pool(pool_hdr);
484 return (char *)tc + TC_HDR_SIZE + pool_hdr->poolsize;
487 static inline size_t tc_pool_space_left(struct talloc_pool_hdr *pool_hdr)
489 return (char *)tc_pool_end(pool_hdr) - (char *)pool_hdr->end;
492 /* If tc is inside a pool, this gives the next neighbour. */
493 static inline void *tc_next_chunk(struct talloc_chunk *tc)
495 return (char *)tc + TC_ALIGN16(TC_HDR_SIZE + tc->size);
498 static inline void *tc_pool_first_chunk(struct talloc_pool_hdr *pool_hdr)
500 struct talloc_chunk *tc = talloc_chunk_from_pool(pool_hdr);
501 return tc_next_chunk(tc);
504 /* Mark the whole remaining pool as not accessable */
505 static inline void tc_invalidate_pool(struct talloc_pool_hdr *pool_hdr)
507 size_t flen = tc_pool_space_left(pool_hdr);
509 if (unlikely(talloc_fill.enabled)) {
510 memset(pool_hdr->end, talloc_fill.fill_value, flen);
513 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
514 VALGRIND_MAKE_MEM_NOACCESS(pool_hdr->end, flen);
522 static inline struct talloc_chunk *talloc_alloc_pool(struct talloc_chunk *parent,
523 size_t size, size_t prefix_len)
525 struct talloc_pool_hdr *pool_hdr = NULL;
527 struct talloc_chunk *result;
530 if (parent == NULL) {
534 if (parent->flags & TALLOC_FLAG_POOL) {
535 pool_hdr = talloc_pool_from_chunk(parent);
537 else if (parent->flags & TALLOC_FLAG_POOLMEM) {
538 pool_hdr = parent->pool;
541 if (pool_hdr == NULL) {
545 space_left = tc_pool_space_left(pool_hdr);
548 * Align size to 16 bytes
550 chunk_size = TC_ALIGN16(size + prefix_len);
552 if (space_left < chunk_size) {
556 result = (struct talloc_chunk *)((char *)pool_hdr->end + prefix_len);
558 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
559 VALGRIND_MAKE_MEM_UNDEFINED(pool_hdr->end, chunk_size);
562 pool_hdr->end = (void *)((char *)pool_hdr->end + chunk_size);
564 result->flags = TALLOC_MAGIC | TALLOC_FLAG_POOLMEM;
565 result->pool = pool_hdr;
567 pool_hdr->object_count++;
573 Allocate a bit of memory as a child of an existing pointer
575 static inline void *__talloc_with_prefix(const void *context, size_t size,
578 struct talloc_chunk *tc = NULL;
579 struct talloc_memlimit *limit = NULL;
580 size_t total_len = TC_HDR_SIZE + size + prefix_len;
582 if (unlikely(context == NULL)) {
583 context = null_context;
586 if (unlikely(size >= MAX_TALLOC_SIZE)) {
590 if (unlikely(total_len < TC_HDR_SIZE)) {
594 if (context != NULL) {
595 struct talloc_chunk *ptc = talloc_chunk_from_ptr(context);
597 if (ptc->limit != NULL) {
601 tc = talloc_alloc_pool(ptc, TC_HDR_SIZE+size, prefix_len);
608 * Only do the memlimit check/update on actual allocation.
610 if (!talloc_memlimit_check(limit, total_len)) {
615 ptr = malloc(total_len);
616 if (unlikely(ptr == NULL)) {
619 tc = (struct talloc_chunk *)(ptr + prefix_len);
620 tc->flags = TALLOC_MAGIC;
623 talloc_memlimit_grow(limit, total_len);
628 tc->destructor = NULL;
633 if (likely(context)) {
634 struct talloc_chunk *parent = talloc_chunk_from_ptr(context);
637 parent->child->parent = NULL;
638 tc->next = parent->child;
647 tc->next = tc->prev = tc->parent = NULL;
650 return TC_PTR_FROM_CHUNK(tc);
653 static inline void *__talloc(const void *context, size_t size)
655 return __talloc_with_prefix(context, size, 0);
659 * Create a talloc pool
662 static inline void *_talloc_pool(const void *context, size_t size)
664 struct talloc_chunk *tc;
665 struct talloc_pool_hdr *pool_hdr;
668 result = __talloc_with_prefix(context, size, TP_HDR_SIZE);
670 if (unlikely(result == NULL)) {
674 tc = talloc_chunk_from_ptr(result);
675 pool_hdr = talloc_pool_from_chunk(tc);
677 tc->flags |= TALLOC_FLAG_POOL;
680 pool_hdr->object_count = 1;
681 pool_hdr->end = result;
682 pool_hdr->poolsize = size;
684 tc_invalidate_pool(pool_hdr);
689 _PUBLIC_ void *talloc_pool(const void *context, size_t size)
691 return _talloc_pool(context, size);
695 * Create a talloc pool correctly sized for a basic size plus
696 * a number of subobjects whose total size is given. Essentially
697 * a custom allocator for talloc to reduce fragmentation.
700 _PUBLIC_ void *_talloc_pooled_object(const void *ctx,
702 const char *type_name,
703 unsigned num_subobjects,
704 size_t total_subobjects_size)
706 size_t poolsize, subobjects_slack, tmp;
707 struct talloc_chunk *tc;
708 struct talloc_pool_hdr *pool_hdr;
711 poolsize = type_size + total_subobjects_size;
713 if ((poolsize < type_size) || (poolsize < total_subobjects_size)) {
717 if (num_subobjects == UINT_MAX) {
720 num_subobjects += 1; /* the object body itself */
723 * Alignment can increase the pool size by at most 15 bytes per object
724 * plus alignment for the object itself
726 subobjects_slack = (TC_HDR_SIZE + TP_HDR_SIZE + 15) * num_subobjects;
727 if (subobjects_slack < num_subobjects) {
731 tmp = poolsize + subobjects_slack;
732 if ((tmp < poolsize) || (tmp < subobjects_slack)) {
737 ret = _talloc_pool(ctx, poolsize);
742 tc = talloc_chunk_from_ptr(ret);
743 tc->size = type_size;
745 pool_hdr = talloc_pool_from_chunk(tc);
747 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
748 VALGRIND_MAKE_MEM_UNDEFINED(pool_hdr->end, type_size);
751 pool_hdr->end = ((char *)pool_hdr->end + TC_ALIGN16(type_size));
753 _talloc_set_name_const(ret, type_name);
761 setup a destructor to be called on free of a pointer
762 the destructor should return 0 on success, or -1 on failure.
763 if the destructor fails then the free is failed, and the memory can
764 be continued to be used
766 _PUBLIC_ void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
768 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
769 tc->destructor = destructor;
773 increase the reference count on a piece of memory.
775 _PUBLIC_ int talloc_increase_ref_count(const void *ptr)
777 if (unlikely(!talloc_reference(null_context, ptr))) {
784 helper for talloc_reference()
786 this is referenced by a function pointer and should not be inline
788 static int talloc_reference_destructor(struct talloc_reference_handle *handle)
790 struct talloc_chunk *ptr_tc = talloc_chunk_from_ptr(handle->ptr);
791 _TLIST_REMOVE(ptr_tc->refs, handle);
796 more efficient way to add a name to a pointer - the name must point to a
799 static inline void _talloc_set_name_const(const void *ptr, const char *name)
801 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
806 internal talloc_named_const()
808 static inline void *_talloc_named_const(const void *context, size_t size, const char *name)
812 ptr = __talloc(context, size);
813 if (unlikely(ptr == NULL)) {
817 _talloc_set_name_const(ptr, name);
823 make a secondary reference to a pointer, hanging off the given context.
824 the pointer remains valid until both the original caller and this given
827 the major use for this is when two different structures need to reference the
828 same underlying data, and you want to be able to free the two instances separately,
831 _PUBLIC_ void *_talloc_reference_loc(const void *context, const void *ptr, const char *location)
833 struct talloc_chunk *tc;
834 struct talloc_reference_handle *handle;
835 if (unlikely(ptr == NULL)) return NULL;
837 tc = talloc_chunk_from_ptr(ptr);
838 handle = (struct talloc_reference_handle *)_talloc_named_const(context,
839 sizeof(struct talloc_reference_handle),
840 TALLOC_MAGIC_REFERENCE);
841 if (unlikely(handle == NULL)) return NULL;
843 /* note that we hang the destructor off the handle, not the
844 main context as that allows the caller to still setup their
845 own destructor on the context if they want to */
846 talloc_set_destructor(handle, talloc_reference_destructor);
847 handle->ptr = discard_const_p(void, ptr);
848 handle->location = location;
849 _TLIST_ADD(tc->refs, handle);
853 static void *_talloc_steal_internal(const void *new_ctx, const void *ptr);
855 static inline void _talloc_free_poolmem(struct talloc_chunk *tc,
856 const char *location)
858 struct talloc_pool_hdr *pool;
859 struct talloc_chunk *pool_tc;
863 pool_tc = talloc_chunk_from_pool(pool);
864 next_tc = tc_next_chunk(tc);
866 tc->flags |= TALLOC_FLAG_FREE;
868 /* we mark the freed memory with where we called the free
869 * from. This means on a double free error we can report where
870 * the first free came from
874 TC_INVALIDATE_FULL_CHUNK(tc);
876 if (unlikely(pool->object_count == 0)) {
877 talloc_abort("Pool object count zero!");
881 pool->object_count--;
883 if (unlikely(pool->object_count == 1
884 && !(pool_tc->flags & TALLOC_FLAG_FREE))) {
886 * if there is just one object left in the pool
887 * and pool->flags does not have TALLOC_FLAG_FREE,
888 * it means this is the pool itself and
889 * the rest is available for new objects
892 pool->end = tc_pool_first_chunk(pool);
893 tc_invalidate_pool(pool);
897 if (unlikely(pool->object_count == 0)) {
899 * we mark the freed memory with where we called the free
900 * from. This means on a double free error we can report where
901 * the first free came from
903 pool_tc->name = location;
905 if (pool_tc->flags & TALLOC_FLAG_POOLMEM) {
906 _talloc_free_poolmem(pool_tc, location);
909 * The talloc_memlimit_update_on_free()
910 * call takes into account the
911 * prefix TP_HDR_SIZE allocated before
912 * the pool talloc_chunk.
914 talloc_memlimit_update_on_free(pool_tc);
915 TC_INVALIDATE_FULL_CHUNK(pool_tc);
921 if (pool->end == next_tc) {
923 * if pool->pool still points to end of
924 * 'tc' (which is stored in the 'next_tc' variable),
925 * we can reclaim the memory of 'tc'.
932 * Do nothing. The memory is just "wasted", waiting for the pool
933 * itself to be freed.
937 static inline void _talloc_free_children_internal(struct talloc_chunk *tc,
939 const char *location);
942 internal talloc_free call
944 static inline int _talloc_free_internal(void *ptr, const char *location)
946 struct talloc_chunk *tc;
949 if (unlikely(ptr == NULL)) {
953 /* possibly initialised the talloc fill value */
954 if (unlikely(!talloc_fill.initialised)) {
955 const char *fill = getenv(TALLOC_FILL_ENV);
957 talloc_fill.enabled = true;
958 talloc_fill.fill_value = strtoul(fill, NULL, 0);
960 talloc_fill.initialised = true;
963 tc = talloc_chunk_from_ptr(ptr);
965 if (unlikely(tc->refs)) {
967 /* check if this is a reference from a child or
968 * grandchild back to it's parent or grandparent
970 * in that case we need to remove the reference and
971 * call another instance of talloc_free() on the current
974 is_child = talloc_is_parent(tc->refs, ptr);
975 _talloc_free_internal(tc->refs, location);
977 return _talloc_free_internal(ptr, location);
982 if (unlikely(tc->flags & TALLOC_FLAG_LOOP)) {
983 /* we have a free loop - stop looping */
987 if (unlikely(tc->destructor)) {
988 talloc_destructor_t d = tc->destructor;
989 if (d == (talloc_destructor_t)-1) {
992 tc->destructor = (talloc_destructor_t)-1;
997 tc->destructor = NULL;
1001 _TLIST_REMOVE(tc->parent->child, tc);
1002 if (tc->parent->child) {
1003 tc->parent->child->parent = tc->parent;
1006 if (tc->prev) tc->prev->next = tc->next;
1007 if (tc->next) tc->next->prev = tc->prev;
1008 tc->prev = tc->next = NULL;
1011 tc->flags |= TALLOC_FLAG_LOOP;
1013 _talloc_free_children_internal(tc, ptr, location);
1015 tc->flags |= TALLOC_FLAG_FREE;
1017 /* we mark the freed memory with where we called the free
1018 * from. This means on a double free error we can report where
1019 * the first free came from
1021 tc->name = location;
1023 if (tc->flags & TALLOC_FLAG_POOL) {
1024 struct talloc_pool_hdr *pool;
1026 pool = talloc_pool_from_chunk(tc);
1028 if (unlikely(pool->object_count == 0)) {
1029 talloc_abort("Pool object count zero!");
1033 pool->object_count--;
1035 if (likely(pool->object_count != 0)) {
1040 * With object_count==0, a pool becomes a normal piece of
1041 * memory to free. If it's allocated inside a pool, it needs
1042 * to be freed as poolmem, else it needs to be just freed.
1049 if (tc->flags & TALLOC_FLAG_POOLMEM) {
1050 _talloc_free_poolmem(tc, location);
1054 talloc_memlimit_update_on_free(tc);
1056 TC_INVALIDATE_FULL_CHUNK(tc);
1061 static size_t _talloc_total_limit_size(const void *ptr,
1062 struct talloc_memlimit *old_limit,
1063 struct talloc_memlimit *new_limit);
1066 move a lump of memory from one talloc context to another return the
1067 ptr on success, or NULL if it could not be transferred.
1068 passing NULL as ptr will always return NULL with no side effects.
1070 static void *_talloc_steal_internal(const void *new_ctx, const void *ptr)
1072 struct talloc_chunk *tc, *new_tc;
1073 size_t ctx_size = 0;
1075 if (unlikely(!ptr)) {
1079 if (unlikely(new_ctx == NULL)) {
1080 new_ctx = null_context;
1083 tc = talloc_chunk_from_ptr(ptr);
1085 if (tc->limit != NULL) {
1087 ctx_size = _talloc_total_limit_size(ptr, NULL, NULL);
1089 /* Decrement the memory limit from the source .. */
1090 talloc_memlimit_shrink(tc->limit->upper, ctx_size);
1092 if (tc->limit->parent == tc) {
1093 tc->limit->upper = NULL;
1099 if (unlikely(new_ctx == NULL)) {
1101 _TLIST_REMOVE(tc->parent->child, tc);
1102 if (tc->parent->child) {
1103 tc->parent->child->parent = tc->parent;
1106 if (tc->prev) tc->prev->next = tc->next;
1107 if (tc->next) tc->next->prev = tc->prev;
1110 tc->parent = tc->next = tc->prev = NULL;
1111 return discard_const_p(void, ptr);
1114 new_tc = talloc_chunk_from_ptr(new_ctx);
1116 if (unlikely(tc == new_tc || tc->parent == new_tc)) {
1117 return discard_const_p(void, ptr);
1121 _TLIST_REMOVE(tc->parent->child, tc);
1122 if (tc->parent->child) {
1123 tc->parent->child->parent = tc->parent;
1126 if (tc->prev) tc->prev->next = tc->next;
1127 if (tc->next) tc->next->prev = tc->prev;
1128 tc->prev = tc->next = NULL;
1131 tc->parent = new_tc;
1132 if (new_tc->child) new_tc->child->parent = NULL;
1133 _TLIST_ADD(new_tc->child, tc);
1135 if (tc->limit || new_tc->limit) {
1136 ctx_size = _talloc_total_limit_size(ptr, tc->limit,
1138 /* .. and increment it in the destination. */
1139 if (new_tc->limit) {
1140 talloc_memlimit_grow(new_tc->limit, ctx_size);
1144 return discard_const_p(void, ptr);
1148 move a lump of memory from one talloc context to another return the
1149 ptr on success, or NULL if it could not be transferred.
1150 passing NULL as ptr will always return NULL with no side effects.
1152 _PUBLIC_ void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *location)
1154 struct talloc_chunk *tc;
1156 if (unlikely(ptr == NULL)) {
1160 tc = talloc_chunk_from_ptr(ptr);
1162 if (unlikely(tc->refs != NULL) && talloc_parent(ptr) != new_ctx) {
1163 struct talloc_reference_handle *h;
1165 talloc_log("WARNING: talloc_steal with references at %s\n",
1168 for (h=tc->refs; h; h=h->next) {
1169 talloc_log("\treference at %s\n",
1175 /* this test is probably too expensive to have on in the
1176 normal build, but it useful for debugging */
1177 if (talloc_is_parent(new_ctx, ptr)) {
1178 talloc_log("WARNING: stealing into talloc child at %s\n", location);
1182 return _talloc_steal_internal(new_ctx, ptr);
1186 this is like a talloc_steal(), but you must supply the old
1187 parent. This resolves the ambiguity in a talloc_steal() which is
1188 called on a context that has more than one parent (via references)
1190 The old parent can be either a reference or a parent
1192 _PUBLIC_ void *talloc_reparent(const void *old_parent, const void *new_parent, const void *ptr)
1194 struct talloc_chunk *tc;
1195 struct talloc_reference_handle *h;
1197 if (unlikely(ptr == NULL)) {
1201 if (old_parent == talloc_parent(ptr)) {
1202 return _talloc_steal_internal(new_parent, ptr);
1205 tc = talloc_chunk_from_ptr(ptr);
1206 for (h=tc->refs;h;h=h->next) {
1207 if (talloc_parent(h) == old_parent) {
1208 if (_talloc_steal_internal(new_parent, h) != h) {
1211 return discard_const_p(void, ptr);
1215 /* it wasn't a parent */
1220 remove a secondary reference to a pointer. This undo's what
1221 talloc_reference() has done. The context and pointer arguments
1222 must match those given to a talloc_reference()
1224 static inline int talloc_unreference(const void *context, const void *ptr)
1226 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1227 struct talloc_reference_handle *h;
1229 if (unlikely(context == NULL)) {
1230 context = null_context;
1233 for (h=tc->refs;h;h=h->next) {
1234 struct talloc_chunk *p = talloc_parent_chunk(h);
1236 if (context == NULL) break;
1237 } else if (TC_PTR_FROM_CHUNK(p) == context) {
1245 return _talloc_free_internal(h, __location__);
1249 remove a specific parent context from a pointer. This is a more
1250 controlled variant of talloc_free()
1252 _PUBLIC_ int talloc_unlink(const void *context, void *ptr)
1254 struct talloc_chunk *tc_p, *new_p, *tc_c;
1261 if (context == NULL) {
1262 context = null_context;
1265 if (talloc_unreference(context, ptr) == 0) {
1269 if (context != NULL) {
1270 tc_c = talloc_chunk_from_ptr(context);
1274 if (tc_c != talloc_parent_chunk(ptr)) {
1278 tc_p = talloc_chunk_from_ptr(ptr);
1280 if (tc_p->refs == NULL) {
1281 return _talloc_free_internal(ptr, __location__);
1284 new_p = talloc_parent_chunk(tc_p->refs);
1286 new_parent = TC_PTR_FROM_CHUNK(new_p);
1291 if (talloc_unreference(new_parent, ptr) != 0) {
1295 _talloc_steal_internal(new_parent, ptr);
1301 add a name to an existing pointer - va_list version
1303 static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
1305 static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
1307 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1308 tc->name = talloc_vasprintf(ptr, fmt, ap);
1309 if (likely(tc->name)) {
1310 _talloc_set_name_const(tc->name, ".name");
1316 add a name to an existing pointer
1318 _PUBLIC_ const char *talloc_set_name(const void *ptr, const char *fmt, ...)
1323 name = talloc_set_name_v(ptr, fmt, ap);
1330 create a named talloc pointer. Any talloc pointer can be named, and
1331 talloc_named() operates just like talloc() except that it allows you
1332 to name the pointer.
1334 _PUBLIC_ void *talloc_named(const void *context, size_t size, const char *fmt, ...)
1340 ptr = __talloc(context, size);
1341 if (unlikely(ptr == NULL)) return NULL;
1344 name = talloc_set_name_v(ptr, fmt, ap);
1347 if (unlikely(name == NULL)) {
1348 _talloc_free_internal(ptr, __location__);
1356 return the name of a talloc ptr, or "UNNAMED"
1358 _PUBLIC_ const char *talloc_get_name(const void *ptr)
1360 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1361 if (unlikely(tc->name == TALLOC_MAGIC_REFERENCE)) {
1362 return ".reference";
1364 if (likely(tc->name)) {
1372 check if a pointer has the given name. If it does, return the pointer,
1373 otherwise return NULL
1375 _PUBLIC_ void *talloc_check_name(const void *ptr, const char *name)
1378 if (unlikely(ptr == NULL)) return NULL;
1379 pname = talloc_get_name(ptr);
1380 if (likely(pname == name || strcmp(pname, name) == 0)) {
1381 return discard_const_p(void, ptr);
1386 static void talloc_abort_type_mismatch(const char *location,
1388 const char *expected)
1392 reason = talloc_asprintf(NULL,
1393 "%s: Type mismatch: name[%s] expected[%s]",
1398 reason = "Type mismatch";
1401 talloc_abort(reason);
1404 _PUBLIC_ void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location)
1408 if (unlikely(ptr == NULL)) {
1409 talloc_abort_type_mismatch(location, NULL, name);
1413 pname = talloc_get_name(ptr);
1414 if (likely(pname == name || strcmp(pname, name) == 0)) {
1415 return discard_const_p(void, ptr);
1418 talloc_abort_type_mismatch(location, pname, name);
1423 this is for compatibility with older versions of talloc
1425 _PUBLIC_ void *talloc_init(const char *fmt, ...)
1431 ptr = __talloc(NULL, 0);
1432 if (unlikely(ptr == NULL)) return NULL;
1435 name = talloc_set_name_v(ptr, fmt, ap);
1438 if (unlikely(name == NULL)) {
1439 _talloc_free_internal(ptr, __location__);
1446 static inline void _talloc_free_children_internal(struct talloc_chunk *tc,
1448 const char *location)
1451 /* we need to work out who will own an abandoned child
1452 if it cannot be freed. In priority order, the first
1453 choice is owner of any remaining reference to this
1454 pointer, the second choice is our parent, and the
1455 final choice is the null context. */
1456 void *child = TC_PTR_FROM_CHUNK(tc->child);
1457 const void *new_parent = null_context;
1458 if (unlikely(tc->child->refs)) {
1459 struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
1460 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
1462 if (unlikely(_talloc_free_internal(child, location) == -1)) {
1463 if (new_parent == null_context) {
1464 struct talloc_chunk *p = talloc_parent_chunk(ptr);
1465 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
1467 _talloc_steal_internal(new_parent, child);
1473 this is a replacement for the Samba3 talloc_destroy_pool functionality. It
1474 should probably not be used in new code. It's in here to keep the talloc
1475 code consistent across Samba 3 and 4.
1477 _PUBLIC_ void talloc_free_children(void *ptr)
1479 struct talloc_chunk *tc_name = NULL;
1480 struct talloc_chunk *tc;
1482 if (unlikely(ptr == NULL)) {
1486 tc = talloc_chunk_from_ptr(ptr);
1488 /* we do not want to free the context name if it is a child .. */
1489 if (likely(tc->child)) {
1490 for (tc_name = tc->child; tc_name; tc_name = tc_name->next) {
1491 if (tc->name == TC_PTR_FROM_CHUNK(tc_name)) break;
1494 _TLIST_REMOVE(tc->child, tc_name);
1496 tc->child->parent = tc;
1501 _talloc_free_children_internal(tc, ptr, __location__);
1503 /* .. so we put it back after all other children have been freed */
1506 tc->child->parent = NULL;
1508 tc_name->parent = tc;
1509 _TLIST_ADD(tc->child, tc_name);
1514 Allocate a bit of memory as a child of an existing pointer
1516 _PUBLIC_ void *_talloc(const void *context, size_t size)
1518 return __talloc(context, size);
1522 externally callable talloc_set_name_const()
1524 _PUBLIC_ void talloc_set_name_const(const void *ptr, const char *name)
1526 _talloc_set_name_const(ptr, name);
1530 create a named talloc pointer. Any talloc pointer can be named, and
1531 talloc_named() operates just like talloc() except that it allows you
1532 to name the pointer.
1534 _PUBLIC_ void *talloc_named_const(const void *context, size_t size, const char *name)
1536 return _talloc_named_const(context, size, name);
1540 free a talloc pointer. This also frees all child pointers of this
1543 return 0 if the memory is actually freed, otherwise -1. The memory
1544 will not be freed if the ref_count is > 1 or the destructor (if
1545 any) returns non-zero
1547 _PUBLIC_ int _talloc_free(void *ptr, const char *location)
1549 struct talloc_chunk *tc;
1551 if (unlikely(ptr == NULL)) {
1555 tc = talloc_chunk_from_ptr(ptr);
1557 if (unlikely(tc->refs != NULL)) {
1558 struct talloc_reference_handle *h;
1560 if (talloc_parent(ptr) == null_context && tc->refs->next == NULL) {
1561 /* in this case we do know which parent should
1562 get this pointer, as there is really only
1564 return talloc_unlink(null_context, ptr);
1567 talloc_log("ERROR: talloc_free with references at %s\n",
1570 for (h=tc->refs; h; h=h->next) {
1571 talloc_log("\treference at %s\n",
1577 return _talloc_free_internal(ptr, location);
1583 A talloc version of realloc. The context argument is only used if
1586 _PUBLIC_ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name)
1588 struct talloc_chunk *tc;
1590 bool malloced = false;
1591 struct talloc_pool_hdr *pool_hdr = NULL;
1592 size_t old_size = 0;
1593 size_t new_size = 0;
1595 /* size zero is equivalent to free() */
1596 if (unlikely(size == 0)) {
1597 talloc_unlink(context, ptr);
1601 if (unlikely(size >= MAX_TALLOC_SIZE)) {
1605 /* realloc(NULL) is equivalent to malloc() */
1607 return _talloc_named_const(context, size, name);
1610 tc = talloc_chunk_from_ptr(ptr);
1612 /* don't allow realloc on referenced pointers */
1613 if (unlikely(tc->refs)) {
1617 /* don't let anybody try to realloc a talloc_pool */
1618 if (unlikely(tc->flags & TALLOC_FLAG_POOL)) {
1622 if (tc->limit && (size > tc->size)) {
1623 if (!talloc_memlimit_check(tc->limit, (size - tc->size))) {
1629 /* handle realloc inside a talloc_pool */
1630 if (unlikely(tc->flags & TALLOC_FLAG_POOLMEM)) {
1631 pool_hdr = tc->pool;
1634 #if (ALWAYS_REALLOC == 0)
1635 /* don't shrink if we have less than 1k to gain */
1636 if (size < tc->size && tc->limit == NULL) {
1638 void *next_tc = tc_next_chunk(tc);
1639 TC_INVALIDATE_SHRINK_CHUNK(tc, size);
1641 if (next_tc == pool_hdr->end) {
1642 /* note: tc->size has changed, so this works */
1643 pool_hdr->end = tc_next_chunk(tc);
1646 } else if ((tc->size - size) < 1024) {
1648 * if we call TC_INVALIDATE_SHRINK_CHUNK() here
1649 * we would need to call TC_UNDEFINE_GROW_CHUNK()
1650 * after each realloc call, which slows down
1651 * testing a lot :-(.
1653 * That is why we only mark memory as undefined here.
1655 TC_UNDEFINE_SHRINK_CHUNK(tc, size);
1657 /* do not shrink if we have less than 1k to gain */
1661 } else if (tc->size == size) {
1663 * do not change the pointer if it is exactly
1670 /* by resetting magic we catch users of the old memory */
1671 tc->flags |= TALLOC_FLAG_FREE;
1675 new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE, 0);
1676 pool_hdr->object_count--;
1678 if (new_ptr == NULL) {
1679 new_ptr = malloc(TC_HDR_SIZE+size);
1685 memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE);
1686 TC_INVALIDATE_FULL_CHUNK(tc);
1689 /* We're doing malloc then free here, so record the difference. */
1690 old_size = tc->size;
1692 new_ptr = malloc(size + TC_HDR_SIZE);
1694 memcpy(new_ptr, tc, MIN(tc->size, size) + TC_HDR_SIZE);
1700 struct talloc_chunk *pool_tc;
1701 void *next_tc = tc_next_chunk(tc);
1702 size_t old_chunk_size = TC_ALIGN16(TC_HDR_SIZE + tc->size);
1703 size_t new_chunk_size = TC_ALIGN16(TC_HDR_SIZE + size);
1704 size_t space_needed;
1706 unsigned int chunk_count = pool_hdr->object_count;
1708 pool_tc = talloc_chunk_from_pool(pool_hdr);
1709 if (!(pool_tc->flags & TALLOC_FLAG_FREE)) {
1713 if (chunk_count == 1) {
1715 * optimize for the case where 'tc' is the only
1716 * chunk in the pool.
1718 char *start = tc_pool_first_chunk(pool_hdr);
1719 space_needed = new_chunk_size;
1720 space_left = (char *)tc_pool_end(pool_hdr) - start;
1722 if (space_left >= space_needed) {
1723 size_t old_used = TC_HDR_SIZE + tc->size;
1724 size_t new_used = TC_HDR_SIZE + size;
1727 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
1731 * start -> tc may have
1732 * been freed and thus been marked as
1733 * VALGRIND_MEM_NOACCESS. Set it to
1734 * VALGRIND_MEM_UNDEFINED so we can
1735 * copy into it without valgrind errors.
1736 * We can't just mark
1737 * new_ptr -> new_ptr + old_used
1738 * as this may overlap on top of tc,
1739 * (which is why we use memmove, not
1740 * memcpy below) hence the MIN.
1742 size_t undef_len = MIN((((char *)tc) - ((char *)new_ptr)),old_used);
1743 VALGRIND_MAKE_MEM_UNDEFINED(new_ptr, undef_len);
1747 memmove(new_ptr, tc, old_used);
1749 tc = (struct talloc_chunk *)new_ptr;
1750 TC_UNDEFINE_GROW_CHUNK(tc, size);
1753 * first we do not align the pool pointer
1754 * because we want to invalidate the padding
1757 pool_hdr->end = new_used + (char *)new_ptr;
1758 tc_invalidate_pool(pool_hdr);
1760 /* now the aligned pointer */
1761 pool_hdr->end = new_chunk_size + (char *)new_ptr;
1768 if (new_chunk_size == old_chunk_size) {
1769 TC_UNDEFINE_GROW_CHUNK(tc, size);
1770 tc->flags &= ~TALLOC_FLAG_FREE;
1775 if (next_tc == pool_hdr->end) {
1777 * optimize for the case where 'tc' is the last
1778 * chunk in the pool.
1780 space_needed = new_chunk_size - old_chunk_size;
1781 space_left = tc_pool_space_left(pool_hdr);
1783 if (space_left >= space_needed) {
1784 TC_UNDEFINE_GROW_CHUNK(tc, size);
1785 tc->flags &= ~TALLOC_FLAG_FREE;
1787 pool_hdr->end = tc_next_chunk(tc);
1792 new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE, 0);
1794 if (new_ptr == NULL) {
1795 new_ptr = malloc(TC_HDR_SIZE+size);
1801 memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE);
1803 _talloc_free_poolmem(tc, __location__ "_talloc_realloc");
1807 /* We're doing realloc here, so record the difference. */
1808 old_size = tc->size;
1810 new_ptr = realloc(tc, size + TC_HDR_SIZE);
1814 if (unlikely(!new_ptr)) {
1815 tc->flags &= ~TALLOC_FLAG_FREE;
1819 tc = (struct talloc_chunk *)new_ptr;
1820 tc->flags &= ~TALLOC_FLAG_FREE;
1822 tc->flags &= ~TALLOC_FLAG_POOLMEM;
1825 tc->parent->child = tc;
1828 tc->child->parent = tc;
1832 tc->prev->next = tc;
1835 tc->next->prev = tc;
1838 if (new_size > old_size) {
1839 talloc_memlimit_grow(tc->limit, new_size - old_size);
1840 } else if (new_size < old_size) {
1841 talloc_memlimit_shrink(tc->limit, old_size - new_size);
1845 _talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
1847 return TC_PTR_FROM_CHUNK(tc);
1851 a wrapper around talloc_steal() for situations where you are moving a pointer
1852 between two structures, and want the old pointer to be set to NULL
1854 _PUBLIC_ void *_talloc_move(const void *new_ctx, const void *_pptr)
1856 const void **pptr = discard_const_p(const void *,_pptr);
1857 void *ret = talloc_steal(new_ctx, discard_const_p(void, *pptr));
1862 enum talloc_mem_count_type {
1868 static inline size_t _talloc_total_mem_internal(const void *ptr,
1869 enum talloc_mem_count_type type,
1870 struct talloc_memlimit *old_limit,
1871 struct talloc_memlimit *new_limit)
1874 struct talloc_chunk *c, *tc;
1883 tc = talloc_chunk_from_ptr(ptr);
1885 if (old_limit || new_limit) {
1886 if (tc->limit && tc->limit->upper == old_limit) {
1887 tc->limit->upper = new_limit;
1891 /* optimize in the memlimits case */
1892 if (type == TOTAL_MEM_LIMIT &&
1893 tc->limit != NULL &&
1894 tc->limit != old_limit &&
1895 tc->limit->parent == tc) {
1896 return tc->limit->cur_size;
1899 if (tc->flags & TALLOC_FLAG_LOOP) {
1903 tc->flags |= TALLOC_FLAG_LOOP;
1905 if (old_limit || new_limit) {
1906 if (old_limit == tc->limit) {
1907 tc->limit = new_limit;
1912 case TOTAL_MEM_SIZE:
1913 if (likely(tc->name != TALLOC_MAGIC_REFERENCE)) {
1917 case TOTAL_MEM_BLOCKS:
1920 case TOTAL_MEM_LIMIT:
1921 if (likely(tc->name != TALLOC_MAGIC_REFERENCE)) {
1923 * Don't count memory allocated from a pool
1924 * when calculating limits. Only count the
1927 if (!(tc->flags & TALLOC_FLAG_POOLMEM)) {
1928 if (tc->flags & TALLOC_FLAG_POOL) {
1930 * If this is a pool, the allocated
1931 * size is in the pool header, and
1932 * remember to add in the prefix
1935 struct talloc_pool_hdr *pool_hdr
1936 = talloc_pool_from_chunk(tc);
1937 total = pool_hdr->poolsize +
1941 total = tc->size + TC_HDR_SIZE;
1947 for (c = tc->child; c; c = c->next) {
1948 total += _talloc_total_mem_internal(TC_PTR_FROM_CHUNK(c), type,
1949 old_limit, new_limit);
1952 tc->flags &= ~TALLOC_FLAG_LOOP;
1958 return the total size of a talloc pool (subtree)
1960 _PUBLIC_ size_t talloc_total_size(const void *ptr)
1962 return _talloc_total_mem_internal(ptr, TOTAL_MEM_SIZE, NULL, NULL);
1966 return the total number of blocks in a talloc pool (subtree)
1968 _PUBLIC_ size_t talloc_total_blocks(const void *ptr)
1970 return _talloc_total_mem_internal(ptr, TOTAL_MEM_BLOCKS, NULL, NULL);
1974 return the number of external references to a pointer
1976 _PUBLIC_ size_t talloc_reference_count(const void *ptr)
1978 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1979 struct talloc_reference_handle *h;
1982 for (h=tc->refs;h;h=h->next) {
1989 report on memory usage by all children of a pointer, giving a full tree view
1991 _PUBLIC_ void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
1992 void (*callback)(const void *ptr,
1993 int depth, int max_depth,
1995 void *private_data),
1998 struct talloc_chunk *c, *tc;
2003 if (ptr == NULL) return;
2005 tc = talloc_chunk_from_ptr(ptr);
2007 if (tc->flags & TALLOC_FLAG_LOOP) {
2011 callback(ptr, depth, max_depth, 0, private_data);
2013 if (max_depth >= 0 && depth >= max_depth) {
2017 tc->flags |= TALLOC_FLAG_LOOP;
2018 for (c=tc->child;c;c=c->next) {
2019 if (c->name == TALLOC_MAGIC_REFERENCE) {
2020 struct talloc_reference_handle *h = (struct talloc_reference_handle *)TC_PTR_FROM_CHUNK(c);
2021 callback(h->ptr, depth + 1, max_depth, 1, private_data);
2023 talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c), depth + 1, max_depth, callback, private_data);
2026 tc->flags &= ~TALLOC_FLAG_LOOP;
2029 static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_depth, int is_ref, void *_f)
2031 const char *name = talloc_get_name(ptr);
2032 struct talloc_chunk *tc;
2033 FILE *f = (FILE *)_f;
2036 fprintf(f, "%*sreference to: %s\n", depth*4, "", name);
2040 tc = talloc_chunk_from_ptr(ptr);
2041 if (tc->limit && tc->limit->parent == tc) {
2042 fprintf(f, "%*s%-30s is a memlimit context"
2043 " (max_size = %lu bytes, cur_size = %lu bytes)\n",
2046 (unsigned long)tc->limit->max_size,
2047 (unsigned long)tc->limit->cur_size);
2051 fprintf(f,"%stalloc report on '%s' (total %6lu bytes in %3lu blocks)\n",
2052 (max_depth < 0 ? "full " :""), name,
2053 (unsigned long)talloc_total_size(ptr),
2054 (unsigned long)talloc_total_blocks(ptr));
2058 fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d) %p\n",
2061 (unsigned long)talloc_total_size(ptr),
2062 (unsigned long)talloc_total_blocks(ptr),
2063 (int)talloc_reference_count(ptr), ptr);
2066 fprintf(f, "content: ");
2067 if (talloc_total_size(ptr)) {
2068 int tot = talloc_total_size(ptr);
2071 for (i = 0; i < tot; i++) {
2072 if ((((char *)ptr)[i] > 31) && (((char *)ptr)[i] < 126)) {
2073 fprintf(f, "%c", ((char *)ptr)[i]);
2075 fprintf(f, "~%02x", ((char *)ptr)[i]);
2084 report on memory usage by all children of a pointer, giving a full tree view
2086 _PUBLIC_ void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f)
2089 talloc_report_depth_cb(ptr, depth, max_depth, talloc_report_depth_FILE_helper, f);
2095 report on memory usage by all children of a pointer, giving a full tree view
2097 _PUBLIC_ void talloc_report_full(const void *ptr, FILE *f)
2099 talloc_report_depth_file(ptr, 0, -1, f);
2103 report on memory usage by all children of a pointer
2105 _PUBLIC_ void talloc_report(const void *ptr, FILE *f)
2107 talloc_report_depth_file(ptr, 0, 1, f);
2111 report on any memory hanging off the null context
2113 static void talloc_report_null(void)
2115 if (talloc_total_size(null_context) != 0) {
2116 talloc_report(null_context, stderr);
2121 report on any memory hanging off the null context
2123 static void talloc_report_null_full(void)
2125 if (talloc_total_size(null_context) != 0) {
2126 talloc_report_full(null_context, stderr);
2131 enable tracking of the NULL context
2133 _PUBLIC_ void talloc_enable_null_tracking(void)
2135 if (null_context == NULL) {
2136 null_context = _talloc_named_const(NULL, 0, "null_context");
2137 if (autofree_context != NULL) {
2138 talloc_reparent(NULL, null_context, autofree_context);
2144 enable tracking of the NULL context, not moving the autofree context
2145 into the NULL context. This is needed for the talloc testsuite
2147 _PUBLIC_ void talloc_enable_null_tracking_no_autofree(void)
2149 if (null_context == NULL) {
2150 null_context = _talloc_named_const(NULL, 0, "null_context");
2155 disable tracking of the NULL context
2157 _PUBLIC_ void talloc_disable_null_tracking(void)
2159 if (null_context != NULL) {
2160 /* we have to move any children onto the real NULL
2162 struct talloc_chunk *tc, *tc2;
2163 tc = talloc_chunk_from_ptr(null_context);
2164 for (tc2 = tc->child; tc2; tc2=tc2->next) {
2165 if (tc2->parent == tc) tc2->parent = NULL;
2166 if (tc2->prev == tc) tc2->prev = NULL;
2168 for (tc2 = tc->next; tc2; tc2=tc2->next) {
2169 if (tc2->parent == tc) tc2->parent = NULL;
2170 if (tc2->prev == tc) tc2->prev = NULL;
2175 talloc_free(null_context);
2176 null_context = NULL;
2180 enable leak reporting on exit
2182 _PUBLIC_ void talloc_enable_leak_report(void)
2184 talloc_enable_null_tracking();
2185 atexit(talloc_report_null);
2189 enable full leak reporting on exit
2191 _PUBLIC_ void talloc_enable_leak_report_full(void)
2193 talloc_enable_null_tracking();
2194 atexit(talloc_report_null_full);
2198 talloc and zero memory.
2200 _PUBLIC_ void *_talloc_zero(const void *ctx, size_t size, const char *name)
2202 void *p = _talloc_named_const(ctx, size, name);
2205 memset(p, '\0', size);
2212 memdup with a talloc.
2214 _PUBLIC_ void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
2216 void *newp = _talloc_named_const(t, size, name);
2219 memcpy(newp, p, size);
2225 static inline char *__talloc_strlendup(const void *t, const char *p, size_t len)
2229 ret = (char *)__talloc(t, len + 1);
2230 if (unlikely(!ret)) return NULL;
2232 memcpy(ret, p, len);
2235 _talloc_set_name_const(ret, ret);
2240 strdup with a talloc
2242 _PUBLIC_ char *talloc_strdup(const void *t, const char *p)
2244 if (unlikely(!p)) return NULL;
2245 return __talloc_strlendup(t, p, strlen(p));
2249 strndup with a talloc
2251 _PUBLIC_ char *talloc_strndup(const void *t, const char *p, size_t n)
2253 if (unlikely(!p)) return NULL;
2254 return __talloc_strlendup(t, p, strnlen(p, n));
2257 static inline char *__talloc_strlendup_append(char *s, size_t slen,
2258 const char *a, size_t alen)
2262 ret = talloc_realloc(NULL, s, char, slen + alen + 1);
2263 if (unlikely(!ret)) return NULL;
2265 /* append the string and the trailing \0 */
2266 memcpy(&ret[slen], a, alen);
2269 _talloc_set_name_const(ret, ret);
2274 * Appends at the end of the string.
2276 _PUBLIC_ char *talloc_strdup_append(char *s, const char *a)
2279 return talloc_strdup(NULL, a);
2286 return __talloc_strlendup_append(s, strlen(s), a, strlen(a));
2290 * Appends at the end of the talloc'ed buffer,
2291 * not the end of the string.
2293 _PUBLIC_ char *talloc_strdup_append_buffer(char *s, const char *a)
2298 return talloc_strdup(NULL, a);
2305 slen = talloc_get_size(s);
2306 if (likely(slen > 0)) {
2310 return __talloc_strlendup_append(s, slen, a, strlen(a));
2314 * Appends at the end of the string.
2316 _PUBLIC_ char *talloc_strndup_append(char *s, const char *a, size_t n)
2319 return talloc_strndup(NULL, a, n);
2326 return __talloc_strlendup_append(s, strlen(s), a, strnlen(a, n));
2330 * Appends at the end of the talloc'ed buffer,
2331 * not the end of the string.
2333 _PUBLIC_ char *talloc_strndup_append_buffer(char *s, const char *a, size_t n)
2338 return talloc_strndup(NULL, a, n);
2345 slen = talloc_get_size(s);
2346 if (likely(slen > 0)) {
2350 return __talloc_strlendup_append(s, slen, a, strnlen(a, n));
2353 #ifndef HAVE_VA_COPY
2354 #ifdef HAVE___VA_COPY
2355 #define va_copy(dest, src) __va_copy(dest, src)
2357 #define va_copy(dest, src) (dest) = (src)
2361 _PUBLIC_ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
2368 /* this call looks strange, but it makes it work on older solaris boxes */
2370 len = vsnprintf(buf, sizeof(buf), fmt, ap2);
2372 if (unlikely(len < 0)) {
2376 ret = (char *)__talloc(t, len+1);
2377 if (unlikely(!ret)) return NULL;
2379 if (len < sizeof(buf)) {
2380 memcpy(ret, buf, len+1);
2383 vsnprintf(ret, len+1, fmt, ap2);
2387 _talloc_set_name_const(ret, ret);
2393 Perform string formatting, and return a pointer to newly allocated
2394 memory holding the result, inside a memory pool.
2396 _PUBLIC_ char *talloc_asprintf(const void *t, const char *fmt, ...)
2402 ret = talloc_vasprintf(t, fmt, ap);
2407 static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
2408 const char *fmt, va_list ap)
2409 PRINTF_ATTRIBUTE(3,0);
2411 static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
2412 const char *fmt, va_list ap)
2419 alen = vsnprintf(&c, 1, fmt, ap2);
2423 /* Either the vsnprintf failed or the format resulted in
2424 * no characters being formatted. In the former case, we
2425 * ought to return NULL, in the latter we ought to return
2426 * the original string. Most current callers of this
2427 * function expect it to never return NULL.
2432 s = talloc_realloc(NULL, s, char, slen + alen + 1);
2433 if (!s) return NULL;
2436 vsnprintf(s + slen, alen + 1, fmt, ap2);
2439 _talloc_set_name_const(s, s);
2444 * Realloc @p s to append the formatted result of @p fmt and @p ap,
2445 * and return @p s, which may have moved. Good for gradually
2446 * accumulating output into a string buffer. Appends at the end
2449 _PUBLIC_ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
2452 return talloc_vasprintf(NULL, fmt, ap);
2455 return __talloc_vaslenprintf_append(s, strlen(s), fmt, ap);
2459 * Realloc @p s to append the formatted result of @p fmt and @p ap,
2460 * and return @p s, which may have moved. Always appends at the
2461 * end of the talloc'ed buffer, not the end of the string.
2463 _PUBLIC_ char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
2468 return talloc_vasprintf(NULL, fmt, ap);
2471 slen = talloc_get_size(s);
2472 if (likely(slen > 0)) {
2476 return __talloc_vaslenprintf_append(s, slen, fmt, ap);
2480 Realloc @p s to append the formatted result of @p fmt and return @p
2481 s, which may have moved. Good for gradually accumulating output
2482 into a string buffer.
2484 _PUBLIC_ char *talloc_asprintf_append(char *s, const char *fmt, ...)
2489 s = talloc_vasprintf_append(s, fmt, ap);
2495 Realloc @p s to append the formatted result of @p fmt and return @p
2496 s, which may have moved. Good for gradually accumulating output
2499 _PUBLIC_ char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...)
2504 s = talloc_vasprintf_append_buffer(s, fmt, ap);
2510 alloc an array, checking for integer overflow in the array size
2512 _PUBLIC_ void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
2514 if (count >= MAX_TALLOC_SIZE/el_size) {
2517 return _talloc_named_const(ctx, el_size * count, name);
2521 alloc an zero array, checking for integer overflow in the array size
2523 _PUBLIC_ void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
2525 if (count >= MAX_TALLOC_SIZE/el_size) {
2528 return _talloc_zero(ctx, el_size * count, name);
2532 realloc an array, checking for integer overflow in the array size
2534 _PUBLIC_ void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
2536 if (count >= MAX_TALLOC_SIZE/el_size) {
2539 return _talloc_realloc(ctx, ptr, el_size * count, name);
2543 a function version of talloc_realloc(), so it can be passed as a function pointer
2544 to libraries that want a realloc function (a realloc function encapsulates
2545 all the basic capabilities of an allocation library, which is why this is useful)
2547 _PUBLIC_ void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
2549 return _talloc_realloc(context, ptr, size, NULL);
2553 static int talloc_autofree_destructor(void *ptr)
2555 autofree_context = NULL;
2559 static void talloc_autofree(void)
2561 talloc_free(autofree_context);
2565 return a context which will be auto-freed on exit
2566 this is useful for reducing the noise in leak reports
2568 _PUBLIC_ void *talloc_autofree_context(void)
2570 if (autofree_context == NULL) {
2571 autofree_context = _talloc_named_const(NULL, 0, "autofree_context");
2572 talloc_set_destructor(autofree_context, talloc_autofree_destructor);
2573 atexit(talloc_autofree);
2575 return autofree_context;
2578 _PUBLIC_ size_t talloc_get_size(const void *context)
2580 struct talloc_chunk *tc;
2582 if (context == NULL) {
2583 context = null_context;
2585 if (context == NULL) {
2589 tc = talloc_chunk_from_ptr(context);
2595 find a parent of this context that has the given name, if any
2597 _PUBLIC_ void *talloc_find_parent_byname(const void *context, const char *name)
2599 struct talloc_chunk *tc;
2601 if (context == NULL) {
2605 tc = talloc_chunk_from_ptr(context);
2607 if (tc->name && strcmp(tc->name, name) == 0) {
2608 return TC_PTR_FROM_CHUNK(tc);
2610 while (tc && tc->prev) tc = tc->prev;
2619 show the parentage of a context
2621 _PUBLIC_ void talloc_show_parents(const void *context, FILE *file)
2623 struct talloc_chunk *tc;
2625 if (context == NULL) {
2626 fprintf(file, "talloc no parents for NULL\n");
2630 tc = talloc_chunk_from_ptr(context);
2631 fprintf(file, "talloc parents of '%s'\n", talloc_get_name(context));
2633 fprintf(file, "\t'%s'\n", talloc_get_name(TC_PTR_FROM_CHUNK(tc)));
2634 while (tc && tc->prev) tc = tc->prev;
2643 return 1 if ptr is a parent of context
2645 static int _talloc_is_parent(const void *context, const void *ptr, int depth)
2647 struct talloc_chunk *tc;
2649 if (context == NULL) {
2653 tc = talloc_chunk_from_ptr(context);
2654 while (tc && depth > 0) {
2655 if (TC_PTR_FROM_CHUNK(tc) == ptr) return 1;
2656 while (tc && tc->prev) tc = tc->prev;
2666 return 1 if ptr is a parent of context
2668 _PUBLIC_ int talloc_is_parent(const void *context, const void *ptr)
2670 return _talloc_is_parent(context, ptr, TALLOC_MAX_DEPTH);
2674 return the total size of memory used by this context and all children
2676 static inline size_t _talloc_total_limit_size(const void *ptr,
2677 struct talloc_memlimit *old_limit,
2678 struct talloc_memlimit *new_limit)
2680 return _talloc_total_mem_internal(ptr, TOTAL_MEM_LIMIT,
2681 old_limit, new_limit);
2684 static inline bool talloc_memlimit_check(struct talloc_memlimit *limit, size_t size)
2686 struct talloc_memlimit *l;
2688 for (l = limit; l != NULL; l = l->upper) {
2689 if (l->max_size != 0 &&
2690 ((l->max_size <= l->cur_size) ||
2691 (l->max_size - l->cur_size < size))) {
2700 Update memory limits when freeing a talloc_chunk.
2702 static void talloc_memlimit_update_on_free(struct talloc_chunk *tc)
2704 size_t limit_shrink_size;
2711 * Pool entries don't count. Only the pools
2712 * themselves are counted as part of the memory
2713 * limits. Note that this also takes care of
2714 * nested pools which have both flags
2715 * TALLOC_FLAG_POOLMEM|TALLOC_FLAG_POOL set.
2717 if (tc->flags & TALLOC_FLAG_POOLMEM) {
2722 * If we are part of a memory limited context hierarchy
2723 * we need to subtract the memory used from the counters
2726 limit_shrink_size = tc->size+TC_HDR_SIZE;
2729 * If we're deallocating a pool, take into
2730 * account the prefix size added for the pool.
2733 if (tc->flags & TALLOC_FLAG_POOL) {
2734 limit_shrink_size += TP_HDR_SIZE;
2737 talloc_memlimit_shrink(tc->limit, limit_shrink_size);
2739 if (tc->limit->parent == tc) {
2747 Increase memory limit accounting after a malloc/realloc.
2749 static void talloc_memlimit_grow(struct talloc_memlimit *limit,
2752 struct talloc_memlimit *l;
2754 for (l = limit; l != NULL; l = l->upper) {
2755 size_t new_cur_size = l->cur_size + size;
2756 if (new_cur_size < l->cur_size) {
2757 talloc_abort("logic error in talloc_memlimit_grow\n");
2760 l->cur_size = new_cur_size;
2765 Decrease memory limit accounting after a free/realloc.
2767 static void talloc_memlimit_shrink(struct talloc_memlimit *limit,
2770 struct talloc_memlimit *l;
2772 for (l = limit; l != NULL; l = l->upper) {
2773 if (l->cur_size < size) {
2774 talloc_abort("logic error in talloc_memlimit_shrink\n");
2777 l->cur_size = l->cur_size - size;
2781 _PUBLIC_ int talloc_set_memlimit(const void *ctx, size_t max_size)
2783 struct talloc_chunk *tc = talloc_chunk_from_ptr(ctx);
2784 struct talloc_memlimit *orig_limit;
2785 struct talloc_memlimit *limit = NULL;
2787 if (tc->limit && tc->limit->parent == tc) {
2788 tc->limit->max_size = max_size;
2791 orig_limit = tc->limit;
2793 limit = malloc(sizeof(struct talloc_memlimit));
2794 if (limit == NULL) {
2798 limit->max_size = max_size;
2799 limit->cur_size = _talloc_total_limit_size(ctx, tc->limit, limit);
2802 limit->upper = orig_limit;
2804 limit->upper = NULL;