source: trunk/server/lib/talloc/talloc.c

Last change on this file was 752, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.9 2nd part
File size: 57.2 KB
RevLine 
[745]1/*
2 Samba Unix SMB/CIFS implementation.
3
4 Samba trivial allocation library - new interface
5
6 NOTE: Please read talloc_guide.txt for full documentation
7
8 Copyright (C) Andrew Tridgell 2004
9 Copyright (C) Stefan Metzmacher 2006
10
11 ** NOTE! The following LGPL license applies to the talloc
12 ** library. This does NOT imply that all of Samba is released
13 ** under the LGPL
14
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.
19
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.
24
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/>.
27*/
28
29/*
30 inspired by http://swapped.cc/halloc/
31*/
32
33#include "replace.h"
34#include "talloc.h"
35
36#ifdef TALLOC_BUILD_VERSION_MAJOR
37#if (TALLOC_VERSION_MAJOR != TALLOC_BUILD_VERSION_MAJOR)
38#error "TALLOC_VERSION_MAJOR != TALLOC_BUILD_VERSION_MAJOR"
39#endif
40#endif
41
42#ifdef TALLOC_BUILD_VERSION_MINOR
43#if (TALLOC_VERSION_MINOR != TALLOC_BUILD_VERSION_MINOR)
44#error "TALLOC_VERSION_MINOR != TALLOC_BUILD_VERSION_MINOR"
45#endif
46#endif
47
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)
54#include <valgrind.h>
55#endif
56
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
60
61
62#define MAX_TALLOC_SIZE 0x10000000
63#define TALLOC_MAGIC_BASE 0xe814ec70
64#define TALLOC_MAGIC ( \
65 TALLOC_MAGIC_BASE + \
66 (TALLOC_VERSION_MAJOR << 12) + \
67 (TALLOC_VERSION_MINOR << 4) \
68)
69
70#define TALLOC_FLAG_FREE 0x01
71#define TALLOC_FLAG_LOOP 0x02
72#define TALLOC_FLAG_POOL 0x04 /* This is a talloc pool */
73#define TALLOC_FLAG_POOLMEM 0x08 /* This is allocated in a pool */
74#define TALLOC_MAGIC_REFERENCE ((const char *)1)
75
76/* by default we abort when given a bad pointer (such as when talloc_free() is called
77 on a pointer that came from malloc() */
78#ifndef TALLOC_ABORT
79#define TALLOC_ABORT(reason) abort()
80#endif
81
82#ifndef discard_const_p
83#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
84# define discard_const_p(type, ptr) ((type *)((intptr_t)(ptr)))
85#else
86# define discard_const_p(type, ptr) ((type *)(ptr))
87#endif
88#endif
89
90/* these macros gain us a few percent of speed on gcc */
91#if (__GNUC__ >= 3)
92/* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
93 as its first argument */
94#ifndef likely
95#define likely(x) __builtin_expect(!!(x), 1)
96#endif
97#ifndef unlikely
98#define unlikely(x) __builtin_expect(!!(x), 0)
99#endif
100#else
101#ifndef likely
102#define likely(x) (x)
103#endif
104#ifndef unlikely
105#define unlikely(x) (x)
106#endif
107#endif
108
109/* this null_context is only used if talloc_enable_leak_report() or
110 talloc_enable_leak_report_full() is called, otherwise it remains
111 NULL
112*/
113static void *null_context;
114static void *autofree_context;
115
116/* used to enable fill of memory on free, which can be useful for
117 * catching use after free errors when valgrind is too slow
118 */
119static struct {
120 bool initialised;
121 bool enabled;
122 uint8_t fill_value;
123} talloc_fill;
124
125#define TALLOC_FILL_ENV "TALLOC_FREE_FILL"
126
127/*
128 * do not wipe the header, to allow the
129 * double-free logic to still work
130 */
131#define TC_INVALIDATE_FULL_FILL_CHUNK(_tc) do { \
132 if (unlikely(talloc_fill.enabled)) { \
133 size_t _flen = (_tc)->size; \
134 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
135 memset(_fptr, talloc_fill.fill_value, _flen); \
136 } \
137} while (0)
138
139#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
140/* Mark the whole chunk as not accessable */
141#define TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc) do { \
142 size_t _flen = TC_HDR_SIZE + (_tc)->size; \
143 char *_fptr = (char *)(_tc); \
144 VALGRIND_MAKE_MEM_NOACCESS(_fptr, _flen); \
145} while(0)
146#else
147#define TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc) do { } while (0)
148#endif
149
150#define TC_INVALIDATE_FULL_CHUNK(_tc) do { \
151 TC_INVALIDATE_FULL_FILL_CHUNK(_tc); \
152 TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc); \
153} while (0)
154
155#define TC_INVALIDATE_SHRINK_FILL_CHUNK(_tc, _new_size) do { \
156 if (unlikely(talloc_fill.enabled)) { \
157 size_t _flen = (_tc)->size - (_new_size); \
158 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
159 _fptr += (_new_size); \
160 memset(_fptr, talloc_fill.fill_value, _flen); \
161 } \
162} while (0)
163
164#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
165/* Mark the unused bytes not accessable */
166#define TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { \
167 size_t _flen = (_tc)->size - (_new_size); \
168 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
169 _fptr += (_new_size); \
170 VALGRIND_MAKE_MEM_NOACCESS(_fptr, _flen); \
171} while (0)
172#else
173#define TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
174#endif
175
176#define TC_INVALIDATE_SHRINK_CHUNK(_tc, _new_size) do { \
177 TC_INVALIDATE_SHRINK_FILL_CHUNK(_tc, _new_size); \
178 TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size); \
179} while (0)
180
181#define TC_UNDEFINE_SHRINK_FILL_CHUNK(_tc, _new_size) do { \
182 if (unlikely(talloc_fill.enabled)) { \
183 size_t _flen = (_tc)->size - (_new_size); \
184 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
185 _fptr += (_new_size); \
186 memset(_fptr, talloc_fill.fill_value, _flen); \
187 } \
188} while (0)
189
190#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
191/* Mark the unused bytes as undefined */
192#define TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { \
193 size_t _flen = (_tc)->size - (_new_size); \
194 char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
195 _fptr += (_new_size); \
196 VALGRIND_MAKE_MEM_UNDEFINED(_fptr, _flen); \
197} while (0)
198#else
199#define TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
200#endif
201
202#define TC_UNDEFINE_SHRINK_CHUNK(_tc, _new_size) do { \
203 TC_UNDEFINE_SHRINK_FILL_CHUNK(_tc, _new_size); \
204 TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size); \
205} while (0)
206
207#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
208/* Mark the new bytes as undefined */
209#define TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size) do { \
210 size_t _old_used = TC_HDR_SIZE + (_tc)->size; \
211 size_t _new_used = TC_HDR_SIZE + (_new_size); \
212 size_t _flen = _new_used - _old_used; \
213 char *_fptr = _old_used + (char *)(_tc); \
214 VALGRIND_MAKE_MEM_UNDEFINED(_fptr, _flen); \
215} while (0)
216#else
217#define TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
218#endif
219
220#define TC_UNDEFINE_GROW_CHUNK(_tc, _new_size) do { \
221 TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size); \
222} while (0)
223
224struct talloc_reference_handle {
225 struct talloc_reference_handle *next, *prev;
226 void *ptr;
227 const char *location;
228};
229
230typedef int (*talloc_destructor_t)(void *);
231
232struct talloc_chunk {
233 struct talloc_chunk *next, *prev;
234 struct talloc_chunk *parent, *child;
235 struct talloc_reference_handle *refs;
236 talloc_destructor_t destructor;
237 const char *name;
238 size_t size;
239 unsigned flags;
240
241 /*
242 * "pool" has dual use:
243 *
244 * For the talloc pool itself (i.e. TALLOC_FLAG_POOL is set), "pool"
245 * marks the end of the currently allocated area.
246 *
247 * For members of the pool (i.e. TALLOC_FLAG_POOLMEM is set), "pool"
248 * is a pointer to the struct talloc_chunk of the pool that it was
249 * allocated from. This way children can quickly find the pool to chew
250 * from.
251 */
252 void *pool;
253};
254
255/* 16 byte alignment seems to keep everyone happy */
256#define TC_ALIGN16(s) (((s)+15)&~15)
257#define TC_HDR_SIZE TC_ALIGN16(sizeof(struct talloc_chunk))
258#define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
259
260_PUBLIC_ int talloc_version_major(void)
261{
262 return TALLOC_VERSION_MAJOR;
263}
264
265_PUBLIC_ int talloc_version_minor(void)
266{
267 return TALLOC_VERSION_MINOR;
268}
269
270static void (*talloc_log_fn)(const char *message);
271
272_PUBLIC_ void talloc_set_log_fn(void (*log_fn)(const char *message))
273{
274 talloc_log_fn = log_fn;
275}
276
277static void talloc_log(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);
278static void talloc_log(const char *fmt, ...)
279{
280 va_list ap;
281 char *message;
282
283 if (!talloc_log_fn) {
284 return;
285 }
286
287 va_start(ap, fmt);
288 message = talloc_vasprintf(NULL, fmt, ap);
289 va_end(ap);
290
291 talloc_log_fn(message);
292 talloc_free(message);
293}
294
295static void talloc_log_stderr(const char *message)
296{
297 fprintf(stderr, "%s", message);
298}
299
300_PUBLIC_ void talloc_set_log_stderr(void)
301{
302 talloc_set_log_fn(talloc_log_stderr);
303}
304
305static void (*talloc_abort_fn)(const char *reason);
306
307_PUBLIC_ void talloc_set_abort_fn(void (*abort_fn)(const char *reason))
308{
309 talloc_abort_fn = abort_fn;
310}
311
312static void talloc_abort(const char *reason)
313{
314 talloc_log("%s\n", reason);
315
316 if (!talloc_abort_fn) {
317 TALLOC_ABORT(reason);
318 }
319
320 talloc_abort_fn(reason);
321}
322
323static void talloc_abort_magic(unsigned magic)
324{
325 unsigned striped = magic - TALLOC_MAGIC_BASE;
326 unsigned major = (striped & 0xFFFFF000) >> 12;
327 unsigned minor = (striped & 0x00000FF0) >> 4;
328 talloc_log("Bad talloc magic[0x%08X/%u/%u] expected[0x%08X/%u/%u]\n",
329 magic, major, minor,
330 TALLOC_MAGIC, TALLOC_VERSION_MAJOR, TALLOC_VERSION_MINOR);
331 talloc_abort("Bad talloc magic value - wrong talloc version used/mixed");
332}
333
334static void talloc_abort_access_after_free(void)
335{
336 talloc_abort("Bad talloc magic value - access after free");
337}
338
339static void talloc_abort_unknown_value(void)
340{
341 talloc_abort("Bad talloc magic value - unknown value");
342}
343
344/* panic if we get a bad magic value */
345static inline struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
346{
347 const char *pp = (const char *)ptr;
348 struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp - TC_HDR_SIZE);
349 if (unlikely((tc->flags & (TALLOC_FLAG_FREE | ~0xF)) != TALLOC_MAGIC)) {
350 if ((tc->flags & (~0xFFF)) == TALLOC_MAGIC_BASE) {
351 talloc_abort_magic(tc->flags & (~0xF));
352 return NULL;
353 }
354
355 if (tc->flags & TALLOC_FLAG_FREE) {
356 talloc_log("talloc: access after free error - first free may be at %s\n", tc->name);
357 talloc_abort_access_after_free();
358 return NULL;
359 } else {
360 talloc_abort_unknown_value();
361 return NULL;
362 }
363 }
364 return tc;
365}
366
367/* hook into the front of the list */
368#define _TLIST_ADD(list, p) \
369do { \
370 if (!(list)) { \
371 (list) = (p); \
372 (p)->next = (p)->prev = NULL; \
373 } else { \
374 (list)->prev = (p); \
375 (p)->next = (list); \
376 (p)->prev = NULL; \
377 (list) = (p); \
378 }\
379} while (0)
380
381/* remove an element from a list - element doesn't have to be in list. */
382#define _TLIST_REMOVE(list, p) \
383do { \
384 if ((p) == (list)) { \
385 (list) = (p)->next; \
386 if (list) (list)->prev = NULL; \
387 } else { \
388 if ((p)->prev) (p)->prev->next = (p)->next; \
389 if ((p)->next) (p)->next->prev = (p)->prev; \
390 } \
391 if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \
392} while (0)
393
394
395/*
396 return the parent chunk of a pointer
397*/
398static inline struct talloc_chunk *talloc_parent_chunk(const void *ptr)
399{
400 struct talloc_chunk *tc;
401
402 if (unlikely(ptr == NULL)) {
403 return NULL;
404 }
405
406 tc = talloc_chunk_from_ptr(ptr);
407 while (tc->prev) tc=tc->prev;
408
409 return tc->parent;
410}
411
412_PUBLIC_ void *talloc_parent(const void *ptr)
413{
414 struct talloc_chunk *tc = talloc_parent_chunk(ptr);
415 return tc? TC_PTR_FROM_CHUNK(tc) : NULL;
416}
417
418/*
419 find parents name
420*/
421_PUBLIC_ const char *talloc_parent_name(const void *ptr)
422{
423 struct talloc_chunk *tc = talloc_parent_chunk(ptr);
424 return tc? tc->name : NULL;
425}
426
427/*
428 A pool carries an in-pool object count count in the first 16 bytes.
429 bytes. This is done to support talloc_steal() to a parent outside of the
430 pool. The count includes the pool itself, so a talloc_free() on a pool will
431 only destroy the pool if the count has dropped to zero. A talloc_free() of a
432 pool member will reduce the count, and eventually also call free(3) on the
433 pool memory.
434
435 The object count is not put into "struct talloc_chunk" because it is only
436 relevant for talloc pools and the alignment to 16 bytes would increase the
437 memory footprint of each talloc chunk by those 16 bytes.
438*/
439
440#define TALLOC_POOL_HDR_SIZE 16
441
442#define TC_POOL_SPACE_LEFT(_pool_tc) \
443 PTR_DIFF(TC_HDR_SIZE + (_pool_tc)->size + (char *)(_pool_tc), \
444 (_pool_tc)->pool)
445
446#define TC_POOL_FIRST_CHUNK(_pool_tc) \
447 ((void *)(TC_HDR_SIZE + TALLOC_POOL_HDR_SIZE + (char *)(_pool_tc)))
448
449#define TC_POOLMEM_CHUNK_SIZE(_tc) \
450 TC_ALIGN16(TC_HDR_SIZE + (_tc)->size)
451
452#define TC_POOLMEM_NEXT_CHUNK(_tc) \
453 ((void *)(TC_POOLMEM_CHUNK_SIZE(tc) + (char*)(_tc)))
454
455/* Mark the whole remaining pool as not accessable */
456#define TC_INVALIDATE_FILL_POOL(_pool_tc) do { \
457 if (unlikely(talloc_fill.enabled)) { \
458 size_t _flen = TC_POOL_SPACE_LEFT(_pool_tc); \
459 char *_fptr = (char *)(_pool_tc)->pool; \
460 memset(_fptr, talloc_fill.fill_value, _flen); \
461 } \
462} while(0)
463
464#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
465/* Mark the whole remaining pool as not accessable */
466#define TC_INVALIDATE_VALGRIND_POOL(_pool_tc) do { \
467 size_t _flen = TC_POOL_SPACE_LEFT(_pool_tc); \
468 char *_fptr = (char *)(_pool_tc)->pool; \
469 VALGRIND_MAKE_MEM_NOACCESS(_fptr, _flen); \
470} while(0)
471#else
472#define TC_INVALIDATE_VALGRIND_POOL(_pool_tc) do { } while (0)
473#endif
474
475#define TC_INVALIDATE_POOL(_pool_tc) do { \
476 TC_INVALIDATE_FILL_POOL(_pool_tc); \
477 TC_INVALIDATE_VALGRIND_POOL(_pool_tc); \
478} while (0)
479
480static unsigned int *talloc_pool_objectcount(struct talloc_chunk *tc)
481{
482 return (unsigned int *)((char *)tc + TC_HDR_SIZE);
483}
484
485/*
486 Allocate from a pool
487*/
488
489static struct talloc_chunk *talloc_alloc_pool(struct talloc_chunk *parent,
490 size_t size)
491{
492 struct talloc_chunk *pool_ctx = NULL;
493 size_t space_left;
494 struct talloc_chunk *result;
495 size_t chunk_size;
496
497 if (parent == NULL) {
498 return NULL;
499 }
500
501 if (parent->flags & TALLOC_FLAG_POOL) {
502 pool_ctx = parent;
503 }
504 else if (parent->flags & TALLOC_FLAG_POOLMEM) {
505 pool_ctx = (struct talloc_chunk *)parent->pool;
506 }
507
508 if (pool_ctx == NULL) {
509 return NULL;
510 }
511
512 space_left = TC_POOL_SPACE_LEFT(pool_ctx);
513
514 /*
515 * Align size to 16 bytes
516 */
517 chunk_size = TC_ALIGN16(size);
518
519 if (space_left < chunk_size) {
520 return NULL;
521 }
522
523 result = (struct talloc_chunk *)pool_ctx->pool;
524
525#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
526 VALGRIND_MAKE_MEM_UNDEFINED(result, size);
527#endif
528
529 pool_ctx->pool = (void *)((char *)result + chunk_size);
530
531 result->flags = TALLOC_MAGIC | TALLOC_FLAG_POOLMEM;
532 result->pool = pool_ctx;
533
534 *talloc_pool_objectcount(pool_ctx) += 1;
535
536 return result;
537}
538
539/*
540 Allocate a bit of memory as a child of an existing pointer
541*/
542static inline void *__talloc(const void *context, size_t size)
543{
544 struct talloc_chunk *tc = NULL;
545
546 if (unlikely(context == NULL)) {
547 context = null_context;
548 }
549
550 if (unlikely(size >= MAX_TALLOC_SIZE)) {
551 return NULL;
552 }
553
554 if (context != NULL) {
555 tc = talloc_alloc_pool(talloc_chunk_from_ptr(context),
556 TC_HDR_SIZE+size);
557 }
558
559 if (tc == NULL) {
560 tc = (struct talloc_chunk *)malloc(TC_HDR_SIZE+size);
561 if (unlikely(tc == NULL)) return NULL;
562 tc->flags = TALLOC_MAGIC;
563 tc->pool = NULL;
564 }
565
566 tc->size = size;
567 tc->destructor = NULL;
568 tc->child = NULL;
569 tc->name = NULL;
570 tc->refs = NULL;
571
572 if (likely(context)) {
573 struct talloc_chunk *parent = talloc_chunk_from_ptr(context);
574
575 if (parent->child) {
576 parent->child->parent = NULL;
577 tc->next = parent->child;
578 tc->next->prev = tc;
579 } else {
580 tc->next = NULL;
581 }
582 tc->parent = parent;
583 tc->prev = NULL;
584 parent->child = tc;
585 } else {
586 tc->next = tc->prev = tc->parent = NULL;
587 }
588
589 return TC_PTR_FROM_CHUNK(tc);
590}
591
592/*
593 * Create a talloc pool
594 */
595
596_PUBLIC_ void *talloc_pool(const void *context, size_t size)
597{
598 void *result = __talloc(context, size + TALLOC_POOL_HDR_SIZE);
599 struct talloc_chunk *tc;
600
601 if (unlikely(result == NULL)) {
602 return NULL;
603 }
604
605 tc = talloc_chunk_from_ptr(result);
606
607 tc->flags |= TALLOC_FLAG_POOL;
608 tc->pool = TC_POOL_FIRST_CHUNK(tc);
609
610 *talloc_pool_objectcount(tc) = 1;
611
612 TC_INVALIDATE_POOL(tc);
613
614 return result;
615}
616
617/*
618 setup a destructor to be called on free of a pointer
619 the destructor should return 0 on success, or -1 on failure.
620 if the destructor fails then the free is failed, and the memory can
621 be continued to be used
622*/
623_PUBLIC_ void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
624{
625 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
626 tc->destructor = destructor;
627}
628
629/*
630 increase the reference count on a piece of memory.
631*/
632_PUBLIC_ int talloc_increase_ref_count(const void *ptr)
633{
634 if (unlikely(!talloc_reference(null_context, ptr))) {
635 return -1;
636 }
637 return 0;
638}
639
640/*
641 helper for talloc_reference()
642
643 this is referenced by a function pointer and should not be inline
644*/
645static int talloc_reference_destructor(struct talloc_reference_handle *handle)
646{
647 struct talloc_chunk *ptr_tc = talloc_chunk_from_ptr(handle->ptr);
648 _TLIST_REMOVE(ptr_tc->refs, handle);
649 return 0;
650}
651
652/*
653 more efficient way to add a name to a pointer - the name must point to a
654 true string constant
655*/
656static inline void _talloc_set_name_const(const void *ptr, const char *name)
657{
658 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
659 tc->name = name;
660}
661
662/*
663 internal talloc_named_const()
664*/
665static inline void *_talloc_named_const(const void *context, size_t size, const char *name)
666{
667 void *ptr;
668
669 ptr = __talloc(context, size);
670 if (unlikely(ptr == NULL)) {
671 return NULL;
672 }
673
674 _talloc_set_name_const(ptr, name);
675
676 return ptr;
677}
678
679/*
680 make a secondary reference to a pointer, hanging off the given context.
681 the pointer remains valid until both the original caller and this given
682 context are freed.
683
684 the major use for this is when two different structures need to reference the
685 same underlying data, and you want to be able to free the two instances separately,
686 and in either order
687*/
688_PUBLIC_ void *_talloc_reference_loc(const void *context, const void *ptr, const char *location)
689{
690 struct talloc_chunk *tc;
691 struct talloc_reference_handle *handle;
692 if (unlikely(ptr == NULL)) return NULL;
693
694 tc = talloc_chunk_from_ptr(ptr);
695 handle = (struct talloc_reference_handle *)_talloc_named_const(context,
696 sizeof(struct talloc_reference_handle),
697 TALLOC_MAGIC_REFERENCE);
698 if (unlikely(handle == NULL)) return NULL;
699
700 /* note that we hang the destructor off the handle, not the
701 main context as that allows the caller to still setup their
702 own destructor on the context if they want to */
703 talloc_set_destructor(handle, talloc_reference_destructor);
704 handle->ptr = discard_const_p(void, ptr);
705 handle->location = location;
706 _TLIST_ADD(tc->refs, handle);
707 return handle->ptr;
708}
709
710static void *_talloc_steal_internal(const void *new_ctx, const void *ptr);
711
712static inline void _talloc_free_poolmem(struct talloc_chunk *tc,
713 const char *location)
714{
715 struct talloc_chunk *pool;
716 void *next_tc;
717 unsigned int *pool_object_count;
718
719 pool = (struct talloc_chunk *)tc->pool;
720 next_tc = TC_POOLMEM_NEXT_CHUNK(tc);
721
722 tc->flags |= TALLOC_FLAG_FREE;
723
724 /* we mark the freed memory with where we called the free
725 * from. This means on a double free error we can report where
726 * the first free came from
727 */
728 tc->name = location;
729
730 TC_INVALIDATE_FULL_CHUNK(tc);
731
732 pool_object_count = talloc_pool_objectcount(pool);
733
734 if (unlikely(*pool_object_count == 0)) {
735 talloc_abort("Pool object count zero!");
736 return;
737 }
738
739 *pool_object_count -= 1;
740
741 if (unlikely(*pool_object_count == 1 && !(pool->flags & TALLOC_FLAG_FREE))) {
742 /*
743 * if there is just one object left in the pool
744 * and pool->flags does not have TALLOC_FLAG_FREE,
745 * it means this is the pool itself and
746 * the rest is available for new objects
747 * again.
748 */
749 pool->pool = TC_POOL_FIRST_CHUNK(pool);
750 TC_INVALIDATE_POOL(pool);
751 } else if (unlikely(*pool_object_count == 0)) {
752 /*
753 * we mark the freed memory with where we called the free
754 * from. This means on a double free error we can report where
755 * the first free came from
756 */
757 pool->name = location;
758
759 TC_INVALIDATE_FULL_CHUNK(pool);
760 free(pool);
761 } else if (pool->pool == next_tc) {
762 /*
763 * if pool->pool still points to end of
764 * 'tc' (which is stored in the 'next_tc' variable),
765 * we can reclaim the memory of 'tc'.
766 */
767 pool->pool = tc;
768 }
769}
770
771static inline void _talloc_free_children_internal(struct talloc_chunk *tc,
772 void *ptr,
773 const char *location);
774
775/*
776 internal talloc_free call
777*/
778static inline int _talloc_free_internal(void *ptr, const char *location)
779{
780 struct talloc_chunk *tc;
781
782 if (unlikely(ptr == NULL)) {
783 return -1;
784 }
785
786 /* possibly initialised the talloc fill value */
787 if (unlikely(!talloc_fill.initialised)) {
788 const char *fill = getenv(TALLOC_FILL_ENV);
789 if (fill != NULL) {
790 talloc_fill.enabled = true;
791 talloc_fill.fill_value = strtoul(fill, NULL, 0);
792 }
793 talloc_fill.initialised = true;
794 }
795
796 tc = talloc_chunk_from_ptr(ptr);
797
798 if (unlikely(tc->refs)) {
799 int is_child;
800 /* check if this is a reference from a child or
801 * grandchild back to it's parent or grandparent
802 *
803 * in that case we need to remove the reference and
804 * call another instance of talloc_free() on the current
805 * pointer.
806 */
807 is_child = talloc_is_parent(tc->refs, ptr);
808 _talloc_free_internal(tc->refs, location);
809 if (is_child) {
810 return _talloc_free_internal(ptr, location);
811 }
812 return -1;
813 }
814
815 if (unlikely(tc->flags & TALLOC_FLAG_LOOP)) {
816 /* we have a free loop - stop looping */
817 return 0;
818 }
819
820 if (unlikely(tc->destructor)) {
821 talloc_destructor_t d = tc->destructor;
822 if (d == (talloc_destructor_t)-1) {
823 return -1;
824 }
825 tc->destructor = (talloc_destructor_t)-1;
826 if (d(ptr) == -1) {
827 tc->destructor = d;
828 return -1;
829 }
830 tc->destructor = NULL;
831 }
832
833 if (tc->parent) {
834 _TLIST_REMOVE(tc->parent->child, tc);
835 if (tc->parent->child) {
836 tc->parent->child->parent = tc->parent;
837 }
838 } else {
839 if (tc->prev) tc->prev->next = tc->next;
840 if (tc->next) tc->next->prev = tc->prev;
[752]841 tc->prev = tc->next = NULL;
[745]842 }
843
844 tc->flags |= TALLOC_FLAG_LOOP;
845
846 _talloc_free_children_internal(tc, ptr, location);
847
848 tc->flags |= TALLOC_FLAG_FREE;
849
850 /* we mark the freed memory with where we called the free
851 * from. This means on a double free error we can report where
852 * the first free came from
853 */
854 tc->name = location;
855
856 if (tc->flags & TALLOC_FLAG_POOL) {
857 unsigned int *pool_object_count;
858
859 pool_object_count = talloc_pool_objectcount(tc);
860
861 if (unlikely(*pool_object_count == 0)) {
862 talloc_abort("Pool object count zero!");
863 return 0;
864 }
865
866 *pool_object_count -= 1;
867
868 if (unlikely(*pool_object_count == 0)) {
869 TC_INVALIDATE_FULL_CHUNK(tc);
870 free(tc);
871 }
872 } else if (tc->flags & TALLOC_FLAG_POOLMEM) {
873 _talloc_free_poolmem(tc, location);
874 } else {
875 TC_INVALIDATE_FULL_CHUNK(tc);
876 free(tc);
877 }
878 return 0;
879}
880
881/*
882 move a lump of memory from one talloc context to another return the
883 ptr on success, or NULL if it could not be transferred.
884 passing NULL as ptr will always return NULL with no side effects.
885*/
886static void *_talloc_steal_internal(const void *new_ctx, const void *ptr)
887{
888 struct talloc_chunk *tc, *new_tc;
889
890 if (unlikely(!ptr)) {
891 return NULL;
892 }
893
894 if (unlikely(new_ctx == NULL)) {
895 new_ctx = null_context;
896 }
897
898 tc = talloc_chunk_from_ptr(ptr);
899
900 if (unlikely(new_ctx == NULL)) {
901 if (tc->parent) {
902 _TLIST_REMOVE(tc->parent->child, tc);
903 if (tc->parent->child) {
904 tc->parent->child->parent = tc->parent;
905 }
906 } else {
907 if (tc->prev) tc->prev->next = tc->next;
908 if (tc->next) tc->next->prev = tc->prev;
909 }
910
911 tc->parent = tc->next = tc->prev = NULL;
912 return discard_const_p(void, ptr);
913 }
914
915 new_tc = talloc_chunk_from_ptr(new_ctx);
916
917 if (unlikely(tc == new_tc || tc->parent == new_tc)) {
918 return discard_const_p(void, ptr);
919 }
920
921 if (tc->parent) {
922 _TLIST_REMOVE(tc->parent->child, tc);
923 if (tc->parent->child) {
924 tc->parent->child->parent = tc->parent;
925 }
926 } else {
927 if (tc->prev) tc->prev->next = tc->next;
928 if (tc->next) tc->next->prev = tc->prev;
[752]929 tc->prev = tc->next = NULL;
[745]930 }
931
932 tc->parent = new_tc;
933 if (new_tc->child) new_tc->child->parent = NULL;
934 _TLIST_ADD(new_tc->child, tc);
935
936 return discard_const_p(void, ptr);
937}
938
939/*
940 move a lump of memory from one talloc context to another return the
941 ptr on success, or NULL if it could not be transferred.
942 passing NULL as ptr will always return NULL with no side effects.
943*/
944_PUBLIC_ void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *location)
945{
946 struct talloc_chunk *tc;
947
948 if (unlikely(ptr == NULL)) {
949 return NULL;
950 }
951
952 tc = talloc_chunk_from_ptr(ptr);
953
954 if (unlikely(tc->refs != NULL) && talloc_parent(ptr) != new_ctx) {
955 struct talloc_reference_handle *h;
956
957 talloc_log("WARNING: talloc_steal with references at %s\n",
958 location);
959
960 for (h=tc->refs; h; h=h->next) {
961 talloc_log("\treference at %s\n",
962 h->location);
963 }
964 }
965
966#if 0
967 /* this test is probably too expensive to have on in the
968 normal build, but it useful for debugging */
969 if (talloc_is_parent(new_ctx, ptr)) {
970 talloc_log("WARNING: stealing into talloc child at %s\n", location);
971 }
972#endif
973
974 return _talloc_steal_internal(new_ctx, ptr);
975}
976
977/*
978 this is like a talloc_steal(), but you must supply the old
979 parent. This resolves the ambiguity in a talloc_steal() which is
980 called on a context that has more than one parent (via references)
981
982 The old parent can be either a reference or a parent
983*/
984_PUBLIC_ void *talloc_reparent(const void *old_parent, const void *new_parent, const void *ptr)
985{
986 struct talloc_chunk *tc;
987 struct talloc_reference_handle *h;
988
989 if (unlikely(ptr == NULL)) {
990 return NULL;
991 }
992
993 if (old_parent == talloc_parent(ptr)) {
994 return _talloc_steal_internal(new_parent, ptr);
995 }
996
997 tc = talloc_chunk_from_ptr(ptr);
998 for (h=tc->refs;h;h=h->next) {
999 if (talloc_parent(h) == old_parent) {
1000 if (_talloc_steal_internal(new_parent, h) != h) {
1001 return NULL;
1002 }
1003 return discard_const_p(void, ptr);
1004 }
1005 }
1006
1007 /* it wasn't a parent */
1008 return NULL;
1009}
1010
1011/*
1012 remove a secondary reference to a pointer. This undo's what
1013 talloc_reference() has done. The context and pointer arguments
1014 must match those given to a talloc_reference()
1015*/
1016static inline int talloc_unreference(const void *context, const void *ptr)
1017{
1018 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1019 struct talloc_reference_handle *h;
1020
1021 if (unlikely(context == NULL)) {
1022 context = null_context;
1023 }
1024
1025 for (h=tc->refs;h;h=h->next) {
1026 struct talloc_chunk *p = talloc_parent_chunk(h);
1027 if (p == NULL) {
1028 if (context == NULL) break;
1029 } else if (TC_PTR_FROM_CHUNK(p) == context) {
1030 break;
1031 }
1032 }
1033 if (h == NULL) {
1034 return -1;
1035 }
1036
1037 return _talloc_free_internal(h, __location__);
1038}
1039
1040/*
1041 remove a specific parent context from a pointer. This is a more
1042 controlled varient of talloc_free()
1043*/
1044_PUBLIC_ int talloc_unlink(const void *context, void *ptr)
1045{
1046 struct talloc_chunk *tc_p, *new_p;
1047 void *new_parent;
1048
1049 if (ptr == NULL) {
1050 return -1;
1051 }
1052
1053 if (context == NULL) {
1054 context = null_context;
1055 }
1056
1057 if (talloc_unreference(context, ptr) == 0) {
1058 return 0;
1059 }
1060
1061 if (context == NULL) {
1062 if (talloc_parent_chunk(ptr) != NULL) {
1063 return -1;
1064 }
1065 } else {
1066 if (talloc_chunk_from_ptr(context) != talloc_parent_chunk(ptr)) {
1067 return -1;
1068 }
1069 }
1070
1071 tc_p = talloc_chunk_from_ptr(ptr);
1072
1073 if (tc_p->refs == NULL) {
1074 return _talloc_free_internal(ptr, __location__);
1075 }
1076
1077 new_p = talloc_parent_chunk(tc_p->refs);
1078 if (new_p) {
1079 new_parent = TC_PTR_FROM_CHUNK(new_p);
1080 } else {
1081 new_parent = NULL;
1082 }
1083
1084 if (talloc_unreference(new_parent, ptr) != 0) {
1085 return -1;
1086 }
1087
1088 _talloc_steal_internal(new_parent, ptr);
1089
1090 return 0;
1091}
1092
1093/*
1094 add a name to an existing pointer - va_list version
1095*/
1096static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
1097
1098static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
1099{
1100 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1101 tc->name = talloc_vasprintf(ptr, fmt, ap);
1102 if (likely(tc->name)) {
1103 _talloc_set_name_const(tc->name, ".name");
1104 }
1105 return tc->name;
1106}
1107
1108/*
1109 add a name to an existing pointer
1110*/
1111_PUBLIC_ const char *talloc_set_name(const void *ptr, const char *fmt, ...)
1112{
1113 const char *name;
1114 va_list ap;
1115 va_start(ap, fmt);
1116 name = talloc_set_name_v(ptr, fmt, ap);
1117 va_end(ap);
1118 return name;
1119}
1120
1121
1122/*
1123 create a named talloc pointer. Any talloc pointer can be named, and
1124 talloc_named() operates just like talloc() except that it allows you
1125 to name the pointer.
1126*/
1127_PUBLIC_ void *talloc_named(const void *context, size_t size, const char *fmt, ...)
1128{
1129 va_list ap;
1130 void *ptr;
1131 const char *name;
1132
1133 ptr = __talloc(context, size);
1134 if (unlikely(ptr == NULL)) return NULL;
1135
1136 va_start(ap, fmt);
1137 name = talloc_set_name_v(ptr, fmt, ap);
1138 va_end(ap);
1139
1140 if (unlikely(name == NULL)) {
1141 _talloc_free_internal(ptr, __location__);
1142 return NULL;
1143 }
1144
1145 return ptr;
1146}
1147
1148/*
1149 return the name of a talloc ptr, or "UNNAMED"
1150*/
1151_PUBLIC_ const char *talloc_get_name(const void *ptr)
1152{
1153 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1154 if (unlikely(tc->name == TALLOC_MAGIC_REFERENCE)) {
1155 return ".reference";
1156 }
1157 if (likely(tc->name)) {
1158 return tc->name;
1159 }
1160 return "UNNAMED";
1161}
1162
1163
1164/*
1165 check if a pointer has the given name. If it does, return the pointer,
1166 otherwise return NULL
1167*/
1168_PUBLIC_ void *talloc_check_name(const void *ptr, const char *name)
1169{
1170 const char *pname;
1171 if (unlikely(ptr == NULL)) return NULL;
1172 pname = talloc_get_name(ptr);
1173 if (likely(pname == name || strcmp(pname, name) == 0)) {
1174 return discard_const_p(void, ptr);
1175 }
1176 return NULL;
1177}
1178
1179static void talloc_abort_type_missmatch(const char *location,
1180 const char *name,
1181 const char *expected)
1182{
1183 const char *reason;
1184
1185 reason = talloc_asprintf(NULL,
1186 "%s: Type mismatch: name[%s] expected[%s]",
1187 location,
1188 name?name:"NULL",
1189 expected);
1190 if (!reason) {
1191 reason = "Type mismatch";
1192 }
1193
1194 talloc_abort(reason);
1195}
1196
1197_PUBLIC_ void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location)
1198{
1199 const char *pname;
1200
1201 if (unlikely(ptr == NULL)) {
1202 talloc_abort_type_missmatch(location, NULL, name);
1203 return NULL;
1204 }
1205
1206 pname = talloc_get_name(ptr);
1207 if (likely(pname == name || strcmp(pname, name) == 0)) {
1208 return discard_const_p(void, ptr);
1209 }
1210
1211 talloc_abort_type_missmatch(location, pname, name);
1212 return NULL;
1213}
1214
1215/*
1216 this is for compatibility with older versions of talloc
1217*/
1218_PUBLIC_ void *talloc_init(const char *fmt, ...)
1219{
1220 va_list ap;
1221 void *ptr;
1222 const char *name;
1223
1224 ptr = __talloc(NULL, 0);
1225 if (unlikely(ptr == NULL)) return NULL;
1226
1227 va_start(ap, fmt);
1228 name = talloc_set_name_v(ptr, fmt, ap);
1229 va_end(ap);
1230
1231 if (unlikely(name == NULL)) {
1232 _talloc_free_internal(ptr, __location__);
1233 return NULL;
1234 }
1235
1236 return ptr;
1237}
1238
1239static inline void _talloc_free_children_internal(struct talloc_chunk *tc,
1240 void *ptr,
1241 const char *location)
1242{
1243 while (tc->child) {
1244 /* we need to work out who will own an abandoned child
1245 if it cannot be freed. In priority order, the first
1246 choice is owner of any remaining reference to this
1247 pointer, the second choice is our parent, and the
1248 final choice is the null context. */
1249 void *child = TC_PTR_FROM_CHUNK(tc->child);
1250 const void *new_parent = null_context;
1251 struct talloc_chunk *old_parent = NULL;
1252 if (unlikely(tc->child->refs)) {
1253 struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
1254 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
1255 }
1256 if (unlikely(_talloc_free_internal(child, location) == -1)) {
1257 if (new_parent == null_context) {
[752]1258 struct talloc_chunk *p = talloc_parent_chunk(ptr);
[745]1259 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
1260 }
1261 _talloc_steal_internal(new_parent, child);
1262 }
1263 }
1264}
1265
1266/*
1267 this is a replacement for the Samba3 talloc_destroy_pool functionality. It
1268 should probably not be used in new code. It's in here to keep the talloc
1269 code consistent across Samba 3 and 4.
1270*/
1271_PUBLIC_ void talloc_free_children(void *ptr)
1272{
[752]1273 struct talloc_chunk *tc_name = NULL;
[745]1274 struct talloc_chunk *tc;
1275
1276 if (unlikely(ptr == NULL)) {
1277 return;
1278 }
1279
1280 tc = talloc_chunk_from_ptr(ptr);
1281
[752]1282 /* we do not want to free the context name if it is a child .. */
1283 if (likely(tc->child)) {
1284 for (tc_name = tc->child; tc_name; tc_name = tc_name->next) {
1285 if (tc->name == TC_PTR_FROM_CHUNK(tc_name)) break;
1286 }
1287 if (tc_name) {
1288 _TLIST_REMOVE(tc->child, tc_name);
1289 if (tc->child) {
1290 tc->child->parent = tc;
1291 }
1292 }
1293 }
1294
[745]1295 _talloc_free_children_internal(tc, ptr, __location__);
[752]1296
1297 /* .. so we put it back after all other children have been freed */
1298 if (tc_name) {
1299 if (tc->child) {
1300 tc->child->parent = NULL;
1301 }
1302 tc_name->parent = tc;
1303 _TLIST_ADD(tc->child, tc_name);
1304 }
[745]1305}
1306
1307/*
1308 Allocate a bit of memory as a child of an existing pointer
1309*/
1310_PUBLIC_ void *_talloc(const void *context, size_t size)
1311{
1312 return __talloc(context, size);
1313}
1314
1315/*
1316 externally callable talloc_set_name_const()
1317*/
1318_PUBLIC_ void talloc_set_name_const(const void *ptr, const char *name)
1319{
1320 _talloc_set_name_const(ptr, name);
1321}
1322
1323/*
1324 create a named talloc pointer. Any talloc pointer can be named, and
1325 talloc_named() operates just like talloc() except that it allows you
1326 to name the pointer.
1327*/
1328_PUBLIC_ void *talloc_named_const(const void *context, size_t size, const char *name)
1329{
1330 return _talloc_named_const(context, size, name);
1331}
1332
1333/*
1334 free a talloc pointer. This also frees all child pointers of this
1335 pointer recursively
1336
1337 return 0 if the memory is actually freed, otherwise -1. The memory
1338 will not be freed if the ref_count is > 1 or the destructor (if
1339 any) returns non-zero
1340*/
1341_PUBLIC_ int _talloc_free(void *ptr, const char *location)
1342{
1343 struct talloc_chunk *tc;
1344
1345 if (unlikely(ptr == NULL)) {
1346 return -1;
1347 }
1348
1349 tc = talloc_chunk_from_ptr(ptr);
1350
1351 if (unlikely(tc->refs != NULL)) {
1352 struct talloc_reference_handle *h;
1353
1354 if (talloc_parent(ptr) == null_context && tc->refs->next == NULL) {
1355 /* in this case we do know which parent should
1356 get this pointer, as there is really only
1357 one parent */
1358 return talloc_unlink(null_context, ptr);
1359 }
1360
1361 talloc_log("ERROR: talloc_free with references at %s\n",
1362 location);
1363
1364 for (h=tc->refs; h; h=h->next) {
1365 talloc_log("\treference at %s\n",
1366 h->location);
1367 }
1368 return -1;
1369 }
1370
1371 return _talloc_free_internal(ptr, location);
1372}
1373
1374
1375
1376/*
1377 A talloc version of realloc. The context argument is only used if
1378 ptr is NULL
1379*/
1380_PUBLIC_ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name)
1381{
1382 struct talloc_chunk *tc;
1383 void *new_ptr;
1384 bool malloced = false;
1385 struct talloc_chunk *pool_tc = NULL;
1386
1387 /* size zero is equivalent to free() */
1388 if (unlikely(size == 0)) {
1389 talloc_unlink(context, ptr);
1390 return NULL;
1391 }
1392
1393 if (unlikely(size >= MAX_TALLOC_SIZE)) {
1394 return NULL;
1395 }
1396
1397 /* realloc(NULL) is equivalent to malloc() */
1398 if (ptr == NULL) {
1399 return _talloc_named_const(context, size, name);
1400 }
1401
1402 tc = talloc_chunk_from_ptr(ptr);
1403
1404 /* don't allow realloc on referenced pointers */
1405 if (unlikely(tc->refs)) {
1406 return NULL;
1407 }
1408
1409 /* don't let anybody try to realloc a talloc_pool */
1410 if (unlikely(tc->flags & TALLOC_FLAG_POOL)) {
1411 return NULL;
1412 }
1413
1414 /* don't let anybody try to realloc a talloc_pool */
1415 if (unlikely(tc->flags & TALLOC_FLAG_POOLMEM)) {
1416 pool_tc = (struct talloc_chunk *)tc->pool;
1417 }
1418
1419#if (ALWAYS_REALLOC == 0)
1420 /* don't shrink if we have less than 1k to gain */
1421 if (size < tc->size) {
1422 if (pool_tc) {
1423 void *next_tc = TC_POOLMEM_NEXT_CHUNK(tc);
1424 TC_INVALIDATE_SHRINK_CHUNK(tc, size);
1425 tc->size = size;
1426 if (next_tc == pool_tc->pool) {
1427 pool_tc->pool = TC_POOLMEM_NEXT_CHUNK(tc);
1428 }
1429 return ptr;
1430 } else if ((tc->size - size) < 1024) {
1431 /*
1432 * if we call TC_INVALIDATE_SHRINK_CHUNK() here
1433 * we would need to call TC_UNDEFINE_GROW_CHUNK()
1434 * after each realloc call, which slows down
1435 * testing a lot :-(.
1436 *
1437 * That is why we only mark memory as undefined here.
1438 */
1439 TC_UNDEFINE_SHRINK_CHUNK(tc, size);
1440
1441 /* do not shrink if we have less than 1k to gain */
1442 tc->size = size;
1443 return ptr;
1444 }
1445 } else if (tc->size == size) {
1446 /*
1447 * do not change the pointer if it is exactly
1448 * the same size.
1449 */
1450 return ptr;
1451 }
1452#endif
1453
1454 /* by resetting magic we catch users of the old memory */
1455 tc->flags |= TALLOC_FLAG_FREE;
1456
1457#if ALWAYS_REALLOC
1458 if (pool_tc) {
1459 new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE);
1460 *talloc_pool_objectcount(pool_tc) -= 1;
1461
1462 if (new_ptr == NULL) {
1463 new_ptr = malloc(TC_HDR_SIZE+size);
1464 malloced = true;
1465 }
1466
1467 if (new_ptr) {
1468 memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE);
1469 TC_INVALIDATE_FULL_CHUNK(tc);
1470 }
1471 } else {
1472 new_ptr = malloc(size + TC_HDR_SIZE);
1473 if (new_ptr) {
1474 memcpy(new_ptr, tc, MIN(tc->size, size) + TC_HDR_SIZE);
1475 free(tc);
1476 }
1477 }
1478#else
1479 if (pool_tc) {
1480 void *next_tc = TC_POOLMEM_NEXT_CHUNK(tc);
1481 size_t old_chunk_size = TC_POOLMEM_CHUNK_SIZE(tc);
1482 size_t new_chunk_size = TC_ALIGN16(TC_HDR_SIZE + size);
1483 size_t space_needed;
1484 size_t space_left;
1485 unsigned int chunk_count = *talloc_pool_objectcount(pool_tc);
1486
1487 if (!(pool_tc->flags & TALLOC_FLAG_FREE)) {
1488 chunk_count -= 1;
1489 }
1490
1491 if (chunk_count == 1) {
1492 /*
1493 * optimize for the case where 'tc' is the only
1494 * chunk in the pool.
1495 */
1496 space_needed = new_chunk_size;
1497 space_left = pool_tc->size - TALLOC_POOL_HDR_SIZE;
1498
1499 if (space_left >= space_needed) {
1500 size_t old_used = TC_HDR_SIZE + tc->size;
1501 size_t new_used = TC_HDR_SIZE + size;
1502 pool_tc->pool = TC_POOL_FIRST_CHUNK(pool_tc);
1503#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
1504 /*
1505 * we need to prepare the memmove into
1506 * the unaccessable area.
1507 */
1508 {
1509 size_t diff = PTR_DIFF(tc, pool_tc->pool);
1510 size_t flen = MIN(diff, old_used);
1511 char *fptr = (char *)pool_tc->pool;
1512 VALGRIND_MAKE_MEM_UNDEFINED(fptr, flen);
1513 }
1514#endif
1515 memmove(pool_tc->pool, tc, old_used);
1516 new_ptr = pool_tc->pool;
1517
1518 tc = (struct talloc_chunk *)new_ptr;
1519 TC_UNDEFINE_GROW_CHUNK(tc, size);
1520
1521 /*
1522 * first we do not align the pool pointer
1523 * because we want to invalidate the padding
1524 * too.
1525 */
1526 pool_tc->pool = new_used + (char *)new_ptr;
1527 TC_INVALIDATE_POOL(pool_tc);
1528
1529 /* now the aligned pointer */
1530 pool_tc->pool = new_chunk_size + (char *)new_ptr;
1531 goto got_new_ptr;
1532 }
1533
1534 next_tc = NULL;
1535 }
1536
1537 if (new_chunk_size == old_chunk_size) {
1538 TC_UNDEFINE_GROW_CHUNK(tc, size);
1539 tc->flags &= ~TALLOC_FLAG_FREE;
1540 tc->size = size;
1541 return ptr;
1542 }
1543
1544 if (next_tc == pool_tc->pool) {
1545 /*
1546 * optimize for the case where 'tc' is the last
1547 * chunk in the pool.
1548 */
1549 space_needed = new_chunk_size - old_chunk_size;
1550 space_left = TC_POOL_SPACE_LEFT(pool_tc);
1551
1552 if (space_left >= space_needed) {
1553 TC_UNDEFINE_GROW_CHUNK(tc, size);
1554 tc->flags &= ~TALLOC_FLAG_FREE;
1555 tc->size = size;
1556 pool_tc->pool = TC_POOLMEM_NEXT_CHUNK(tc);
1557 return ptr;
1558 }
1559 }
1560
1561 new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE);
1562
1563 if (new_ptr == NULL) {
1564 new_ptr = malloc(TC_HDR_SIZE+size);
1565 malloced = true;
1566 }
1567
1568 if (new_ptr) {
1569 memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE);
1570
1571 _talloc_free_poolmem(tc, __location__ "_talloc_realloc");
1572 }
1573 }
1574 else {
1575 new_ptr = realloc(tc, size + TC_HDR_SIZE);
1576 }
1577got_new_ptr:
1578#endif
1579 if (unlikely(!new_ptr)) {
1580 tc->flags &= ~TALLOC_FLAG_FREE;
1581 return NULL;
1582 }
1583
1584 tc = (struct talloc_chunk *)new_ptr;
1585 tc->flags &= ~TALLOC_FLAG_FREE;
1586 if (malloced) {
1587 tc->flags &= ~TALLOC_FLAG_POOLMEM;
1588 }
1589 if (tc->parent) {
1590 tc->parent->child = tc;
1591 }
1592 if (tc->child) {
1593 tc->child->parent = tc;
1594 }
1595
1596 if (tc->prev) {
1597 tc->prev->next = tc;
1598 }
1599 if (tc->next) {
1600 tc->next->prev = tc;
1601 }
1602
1603 tc->size = size;
1604 _talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
1605
1606 return TC_PTR_FROM_CHUNK(tc);
1607}
1608
1609/*
1610 a wrapper around talloc_steal() for situations where you are moving a pointer
1611 between two structures, and want the old pointer to be set to NULL
1612*/
1613_PUBLIC_ void *_talloc_move(const void *new_ctx, const void *_pptr)
1614{
1615 const void **pptr = discard_const_p(const void *,_pptr);
1616 void *ret = talloc_steal(new_ctx, discard_const_p(void, *pptr));
1617 (*pptr) = NULL;
1618 return ret;
1619}
1620
1621/*
1622 return the total size of a talloc pool (subtree)
1623*/
1624_PUBLIC_ size_t talloc_total_size(const void *ptr)
1625{
1626 size_t total = 0;
1627 struct talloc_chunk *c, *tc;
1628
1629 if (ptr == NULL) {
1630 ptr = null_context;
1631 }
1632 if (ptr == NULL) {
1633 return 0;
1634 }
1635
1636 tc = talloc_chunk_from_ptr(ptr);
1637
1638 if (tc->flags & TALLOC_FLAG_LOOP) {
1639 return 0;
1640 }
1641
1642 tc->flags |= TALLOC_FLAG_LOOP;
1643
1644 if (likely(tc->name != TALLOC_MAGIC_REFERENCE)) {
1645 total = tc->size;
1646 }
1647 for (c=tc->child;c;c=c->next) {
1648 total += talloc_total_size(TC_PTR_FROM_CHUNK(c));
1649 }
1650
1651 tc->flags &= ~TALLOC_FLAG_LOOP;
1652
1653 return total;
1654}
1655
1656/*
1657 return the total number of blocks in a talloc pool (subtree)
1658*/
1659_PUBLIC_ size_t talloc_total_blocks(const void *ptr)
1660{
1661 size_t total = 0;
1662 struct talloc_chunk *c, *tc;
1663
1664 if (ptr == NULL) {
1665 ptr = null_context;
1666 }
1667 if (ptr == NULL) {
1668 return 0;
1669 }
1670
1671 tc = talloc_chunk_from_ptr(ptr);
1672
1673 if (tc->flags & TALLOC_FLAG_LOOP) {
1674 return 0;
1675 }
1676
1677 tc->flags |= TALLOC_FLAG_LOOP;
1678
1679 total++;
1680 for (c=tc->child;c;c=c->next) {
1681 total += talloc_total_blocks(TC_PTR_FROM_CHUNK(c));
1682 }
1683
1684 tc->flags &= ~TALLOC_FLAG_LOOP;
1685
1686 return total;
1687}
1688
1689/*
1690 return the number of external references to a pointer
1691*/
1692_PUBLIC_ size_t talloc_reference_count(const void *ptr)
1693{
1694 struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1695 struct talloc_reference_handle *h;
1696 size_t ret = 0;
1697
1698 for (h=tc->refs;h;h=h->next) {
1699 ret++;
1700 }
1701 return ret;
1702}
1703
1704/*
1705 report on memory usage by all children of a pointer, giving a full tree view
1706*/
1707_PUBLIC_ void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
1708 void (*callback)(const void *ptr,
1709 int depth, int max_depth,
1710 int is_ref,
1711 void *private_data),
1712 void *private_data)
1713{
1714 struct talloc_chunk *c, *tc;
1715
1716 if (ptr == NULL) {
1717 ptr = null_context;
1718 }
1719 if (ptr == NULL) return;
1720
1721 tc = talloc_chunk_from_ptr(ptr);
1722
1723 if (tc->flags & TALLOC_FLAG_LOOP) {
1724 return;
1725 }
1726
1727 callback(ptr, depth, max_depth, 0, private_data);
1728
1729 if (max_depth >= 0 && depth >= max_depth) {
1730 return;
1731 }
1732
1733 tc->flags |= TALLOC_FLAG_LOOP;
1734 for (c=tc->child;c;c=c->next) {
1735 if (c->name == TALLOC_MAGIC_REFERENCE) {
1736 struct talloc_reference_handle *h = (struct talloc_reference_handle *)TC_PTR_FROM_CHUNK(c);
1737 callback(h->ptr, depth + 1, max_depth, 1, private_data);
1738 } else {
1739 talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c), depth + 1, max_depth, callback, private_data);
1740 }
1741 }
1742 tc->flags &= ~TALLOC_FLAG_LOOP;
1743}
1744
1745static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_depth, int is_ref, void *_f)
1746{
1747 const char *name = talloc_get_name(ptr);
1748 FILE *f = (FILE *)_f;
1749
1750 if (is_ref) {
1751 fprintf(f, "%*sreference to: %s\n", depth*4, "", name);
1752 return;
1753 }
1754
1755 if (depth == 0) {
1756 fprintf(f,"%stalloc report on '%s' (total %6lu bytes in %3lu blocks)\n",
1757 (max_depth < 0 ? "full " :""), name,
1758 (unsigned long)talloc_total_size(ptr),
1759 (unsigned long)talloc_total_blocks(ptr));
1760 return;
1761 }
1762
1763 fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d) %p\n",
1764 depth*4, "",
1765 name,
1766 (unsigned long)talloc_total_size(ptr),
1767 (unsigned long)talloc_total_blocks(ptr),
1768 (int)talloc_reference_count(ptr), ptr);
1769
1770#if 0
1771 fprintf(f, "content: ");
1772 if (talloc_total_size(ptr)) {
1773 int tot = talloc_total_size(ptr);
1774 int i;
1775
1776 for (i = 0; i < tot; i++) {
1777 if ((((char *)ptr)[i] > 31) && (((char *)ptr)[i] < 126)) {
1778 fprintf(f, "%c", ((char *)ptr)[i]);
1779 } else {
1780 fprintf(f, "~%02x", ((char *)ptr)[i]);
1781 }
1782 }
1783 }
1784 fprintf(f, "\n");
1785#endif
1786}
1787
1788/*
1789 report on memory usage by all children of a pointer, giving a full tree view
1790*/
1791_PUBLIC_ void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f)
1792{
1793 if (f) {
1794 talloc_report_depth_cb(ptr, depth, max_depth, talloc_report_depth_FILE_helper, f);
1795 fflush(f);
1796 }
1797}
1798
1799/*
1800 report on memory usage by all children of a pointer, giving a full tree view
1801*/
1802_PUBLIC_ void talloc_report_full(const void *ptr, FILE *f)
1803{
1804 talloc_report_depth_file(ptr, 0, -1, f);
1805}
1806
1807/*
1808 report on memory usage by all children of a pointer
1809*/
1810_PUBLIC_ void talloc_report(const void *ptr, FILE *f)
1811{
1812 talloc_report_depth_file(ptr, 0, 1, f);
1813}
1814
1815/*
1816 report on any memory hanging off the null context
1817*/
1818static void talloc_report_null(void)
1819{
1820 if (talloc_total_size(null_context) != 0) {
1821 talloc_report(null_context, stderr);
1822 }
1823}
1824
1825/*
1826 report on any memory hanging off the null context
1827*/
1828static void talloc_report_null_full(void)
1829{
1830 if (talloc_total_size(null_context) != 0) {
1831 talloc_report_full(null_context, stderr);
1832 }
1833}
1834
1835/*
1836 enable tracking of the NULL context
1837*/
1838_PUBLIC_ void talloc_enable_null_tracking(void)
1839{
1840 if (null_context == NULL) {
1841 null_context = _talloc_named_const(NULL, 0, "null_context");
1842 if (autofree_context != NULL) {
1843 talloc_reparent(NULL, null_context, autofree_context);
1844 }
1845 }
1846}
1847
1848/*
1849 enable tracking of the NULL context, not moving the autofree context
1850 into the NULL context. This is needed for the talloc testsuite
1851*/
1852_PUBLIC_ void talloc_enable_null_tracking_no_autofree(void)
1853{
1854 if (null_context == NULL) {
1855 null_context = _talloc_named_const(NULL, 0, "null_context");
1856 }
1857}
1858
1859/*
1860 disable tracking of the NULL context
1861*/
1862_PUBLIC_ void talloc_disable_null_tracking(void)
1863{
1864 if (null_context != NULL) {
1865 /* we have to move any children onto the real NULL
1866 context */
1867 struct talloc_chunk *tc, *tc2;
1868 tc = talloc_chunk_from_ptr(null_context);
1869 for (tc2 = tc->child; tc2; tc2=tc2->next) {
1870 if (tc2->parent == tc) tc2->parent = NULL;
1871 if (tc2->prev == tc) tc2->prev = NULL;
1872 }
1873 for (tc2 = tc->next; tc2; tc2=tc2->next) {
1874 if (tc2->parent == tc) tc2->parent = NULL;
1875 if (tc2->prev == tc) tc2->prev = NULL;
1876 }
1877 tc->child = NULL;
1878 tc->next = NULL;
1879 }
1880 talloc_free(null_context);
1881 null_context = NULL;
1882}
1883
1884/*
1885 enable leak reporting on exit
1886*/
1887_PUBLIC_ void talloc_enable_leak_report(void)
1888{
1889 talloc_enable_null_tracking();
1890 atexit(talloc_report_null);
1891}
1892
1893/*
1894 enable full leak reporting on exit
1895*/
1896_PUBLIC_ void talloc_enable_leak_report_full(void)
1897{
1898 talloc_enable_null_tracking();
1899 atexit(talloc_report_null_full);
1900}
1901
1902/*
1903 talloc and zero memory.
1904*/
1905_PUBLIC_ void *_talloc_zero(const void *ctx, size_t size, const char *name)
1906{
1907 void *p = _talloc_named_const(ctx, size, name);
1908
1909 if (p) {
1910 memset(p, '\0', size);
1911 }
1912
1913 return p;
1914}
1915
1916/*
1917 memdup with a talloc.
1918*/
1919_PUBLIC_ void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
1920{
1921 void *newp = _talloc_named_const(t, size, name);
1922
1923 if (likely(newp)) {
1924 memcpy(newp, p, size);
1925 }
1926
1927 return newp;
1928}
1929
1930static inline char *__talloc_strlendup(const void *t, const char *p, size_t len)
1931{
1932 char *ret;
1933
1934 ret = (char *)__talloc(t, len + 1);
1935 if (unlikely(!ret)) return NULL;
1936
1937 memcpy(ret, p, len);
1938 ret[len] = 0;
1939
1940 _talloc_set_name_const(ret, ret);
1941 return ret;
1942}
1943
1944/*
1945 strdup with a talloc
1946*/
1947_PUBLIC_ char *talloc_strdup(const void *t, const char *p)
1948{
1949 if (unlikely(!p)) return NULL;
1950 return __talloc_strlendup(t, p, strlen(p));
1951}
1952
1953/*
1954 strndup with a talloc
1955*/
1956_PUBLIC_ char *talloc_strndup(const void *t, const char *p, size_t n)
1957{
1958 if (unlikely(!p)) return NULL;
1959 return __talloc_strlendup(t, p, strnlen(p, n));
1960}
1961
1962static inline char *__talloc_strlendup_append(char *s, size_t slen,
1963 const char *a, size_t alen)
1964{
1965 char *ret;
1966
1967 ret = talloc_realloc(NULL, s, char, slen + alen + 1);
1968 if (unlikely(!ret)) return NULL;
1969
1970 /* append the string and the trailing \0 */
1971 memcpy(&ret[slen], a, alen);
1972 ret[slen+alen] = 0;
1973
1974 _talloc_set_name_const(ret, ret);
1975 return ret;
1976}
1977
1978/*
1979 * Appends at the end of the string.
1980 */
1981_PUBLIC_ char *talloc_strdup_append(char *s, const char *a)
1982{
1983 if (unlikely(!s)) {
1984 return talloc_strdup(NULL, a);
1985 }
1986
1987 if (unlikely(!a)) {
1988 return s;
1989 }
1990
1991 return __talloc_strlendup_append(s, strlen(s), a, strlen(a));
1992}
1993
1994/*
1995 * Appends at the end of the talloc'ed buffer,
1996 * not the end of the string.
1997 */
1998_PUBLIC_ char *talloc_strdup_append_buffer(char *s, const char *a)
1999{
2000 size_t slen;
2001
2002 if (unlikely(!s)) {
2003 return talloc_strdup(NULL, a);
2004 }
2005
2006 if (unlikely(!a)) {
2007 return s;
2008 }
2009
2010 slen = talloc_get_size(s);
2011 if (likely(slen > 0)) {
2012 slen--;
2013 }
2014
2015 return __talloc_strlendup_append(s, slen, a, strlen(a));
2016}
2017
2018/*
2019 * Appends at the end of the string.
2020 */
2021_PUBLIC_ char *talloc_strndup_append(char *s, const char *a, size_t n)
2022{
2023 if (unlikely(!s)) {
2024 return talloc_strdup(NULL, a);
2025 }
2026
2027 if (unlikely(!a)) {
2028 return s;
2029 }
2030
2031 return __talloc_strlendup_append(s, strlen(s), a, strnlen(a, n));
2032}
2033
2034/*
2035 * Appends at the end of the talloc'ed buffer,
2036 * not the end of the string.
2037 */
2038_PUBLIC_ char *talloc_strndup_append_buffer(char *s, const char *a, size_t n)
2039{
2040 size_t slen;
2041
2042 if (unlikely(!s)) {
2043 return talloc_strdup(NULL, a);
2044 }
2045
2046 if (unlikely(!a)) {
2047 return s;
2048 }
2049
2050 slen = talloc_get_size(s);
2051 if (likely(slen > 0)) {
2052 slen--;
2053 }
2054
2055 return __talloc_strlendup_append(s, slen, a, strnlen(a, n));
2056}
2057
2058#ifndef HAVE_VA_COPY
2059#ifdef HAVE___VA_COPY
2060#define va_copy(dest, src) __va_copy(dest, src)
2061#else
2062#define va_copy(dest, src) (dest) = (src)
2063#endif
2064#endif
2065
2066_PUBLIC_ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
2067{
2068 int len;
2069 char *ret;
2070 va_list ap2;
2071 char c;
2072
2073 /* this call looks strange, but it makes it work on older solaris boxes */
2074 va_copy(ap2, ap);
2075 len = vsnprintf(&c, 1, fmt, ap2);
2076 va_end(ap2);
2077 if (unlikely(len < 0)) {
2078 return NULL;
2079 }
2080
2081 ret = (char *)__talloc(t, len+1);
2082 if (unlikely(!ret)) return NULL;
2083
2084 va_copy(ap2, ap);
2085 vsnprintf(ret, len+1, fmt, ap2);
2086 va_end(ap2);
2087
2088 _talloc_set_name_const(ret, ret);
2089 return ret;
2090}
2091
2092
2093/*
2094 Perform string formatting, and return a pointer to newly allocated
2095 memory holding the result, inside a memory pool.
2096 */
2097_PUBLIC_ char *talloc_asprintf(const void *t, const char *fmt, ...)
2098{
2099 va_list ap;
2100 char *ret;
2101
2102 va_start(ap, fmt);
2103 ret = talloc_vasprintf(t, fmt, ap);
2104 va_end(ap);
2105 return ret;
2106}
2107
2108static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
2109 const char *fmt, va_list ap)
2110 PRINTF_ATTRIBUTE(3,0);
2111
2112static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
2113 const char *fmt, va_list ap)
2114{
2115 ssize_t alen;
2116 va_list ap2;
2117 char c;
2118
2119 va_copy(ap2, ap);
2120 alen = vsnprintf(&c, 1, fmt, ap2);
2121 va_end(ap2);
2122
2123 if (alen <= 0) {
2124 /* Either the vsnprintf failed or the format resulted in
2125 * no characters being formatted. In the former case, we
2126 * ought to return NULL, in the latter we ought to return
2127 * the original string. Most current callers of this
2128 * function expect it to never return NULL.
2129 */
2130 return s;
2131 }
2132
2133 s = talloc_realloc(NULL, s, char, slen + alen + 1);
2134 if (!s) return NULL;
2135
2136 va_copy(ap2, ap);
2137 vsnprintf(s + slen, alen + 1, fmt, ap2);
2138 va_end(ap2);
2139
2140 _talloc_set_name_const(s, s);
2141 return s;
2142}
2143
2144/**
2145 * Realloc @p s to append the formatted result of @p fmt and @p ap,
2146 * and return @p s, which may have moved. Good for gradually
2147 * accumulating output into a string buffer. Appends at the end
2148 * of the string.
2149 **/
2150_PUBLIC_ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
2151{
2152 if (unlikely(!s)) {
2153 return talloc_vasprintf(NULL, fmt, ap);
2154 }
2155
2156 return __talloc_vaslenprintf_append(s, strlen(s), fmt, ap);
2157}
2158
2159/**
2160 * Realloc @p s to append the formatted result of @p fmt and @p ap,
2161 * and return @p s, which may have moved. Always appends at the
2162 * end of the talloc'ed buffer, not the end of the string.
2163 **/
2164_PUBLIC_ char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
2165{
2166 size_t slen;
2167
2168 if (unlikely(!s)) {
2169 return talloc_vasprintf(NULL, fmt, ap);
2170 }
2171
2172 slen = talloc_get_size(s);
2173 if (likely(slen > 0)) {
2174 slen--;
2175 }
2176
2177 return __talloc_vaslenprintf_append(s, slen, fmt, ap);
2178}
2179
2180/*
2181 Realloc @p s to append the formatted result of @p fmt and return @p
2182 s, which may have moved. Good for gradually accumulating output
2183 into a string buffer.
2184 */
2185_PUBLIC_ char *talloc_asprintf_append(char *s, const char *fmt, ...)
2186{
2187 va_list ap;
2188
2189 va_start(ap, fmt);
2190 s = talloc_vasprintf_append(s, fmt, ap);
2191 va_end(ap);
2192 return s;
2193}
2194
2195/*
2196 Realloc @p s to append the formatted result of @p fmt and return @p
2197 s, which may have moved. Good for gradually accumulating output
2198 into a buffer.
2199 */
2200_PUBLIC_ char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...)
2201{
2202 va_list ap;
2203
2204 va_start(ap, fmt);
2205 s = talloc_vasprintf_append_buffer(s, fmt, ap);
2206 va_end(ap);
2207 return s;
2208}
2209
2210/*
2211 alloc an array, checking for integer overflow in the array size
2212*/
2213_PUBLIC_ void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
2214{
2215 if (count >= MAX_TALLOC_SIZE/el_size) {
2216 return NULL;
2217 }
2218 return _talloc_named_const(ctx, el_size * count, name);
2219}
2220
2221/*
2222 alloc an zero array, checking for integer overflow in the array size
2223*/
2224_PUBLIC_ void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
2225{
2226 if (count >= MAX_TALLOC_SIZE/el_size) {
2227 return NULL;
2228 }
2229 return _talloc_zero(ctx, el_size * count, name);
2230}
2231
2232/*
2233 realloc an array, checking for integer overflow in the array size
2234*/
2235_PUBLIC_ void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
2236{
2237 if (count >= MAX_TALLOC_SIZE/el_size) {
2238 return NULL;
2239 }
2240 return _talloc_realloc(ctx, ptr, el_size * count, name);
2241}
2242
2243/*
2244 a function version of talloc_realloc(), so it can be passed as a function pointer
2245 to libraries that want a realloc function (a realloc function encapsulates
2246 all the basic capabilities of an allocation library, which is why this is useful)
2247*/
2248_PUBLIC_ void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
2249{
2250 return _talloc_realloc(context, ptr, size, NULL);
2251}
2252
2253
2254static int talloc_autofree_destructor(void *ptr)
2255{
2256 autofree_context = NULL;
2257 return 0;
2258}
2259
2260static void talloc_autofree(void)
2261{
2262 talloc_free(autofree_context);
2263}
2264
2265/*
2266 return a context which will be auto-freed on exit
2267 this is useful for reducing the noise in leak reports
2268*/
2269_PUBLIC_ void *talloc_autofree_context(void)
2270{
2271 if (autofree_context == NULL) {
2272 autofree_context = _talloc_named_const(NULL, 0, "autofree_context");
2273 talloc_set_destructor(autofree_context, talloc_autofree_destructor);
2274 atexit(talloc_autofree);
2275 }
2276 return autofree_context;
2277}
2278
2279_PUBLIC_ size_t talloc_get_size(const void *context)
2280{
2281 struct talloc_chunk *tc;
2282
2283 if (context == NULL) {
2284 context = null_context;
2285 }
2286 if (context == NULL) {
2287 return 0;
2288 }
2289
2290 tc = talloc_chunk_from_ptr(context);
2291
2292 return tc->size;
2293}
2294
2295/*
2296 find a parent of this context that has the given name, if any
2297*/
2298_PUBLIC_ void *talloc_find_parent_byname(const void *context, const char *name)
2299{
2300 struct talloc_chunk *tc;
2301
2302 if (context == NULL) {
2303 return NULL;
2304 }
2305
2306 tc = talloc_chunk_from_ptr(context);
2307 while (tc) {
2308 if (tc->name && strcmp(tc->name, name) == 0) {
2309 return TC_PTR_FROM_CHUNK(tc);
2310 }
2311 while (tc && tc->prev) tc = tc->prev;
2312 if (tc) {
2313 tc = tc->parent;
2314 }
2315 }
2316 return NULL;
2317}
2318
2319/*
2320 show the parentage of a context
2321*/
2322_PUBLIC_ void talloc_show_parents(const void *context, FILE *file)
2323{
2324 struct talloc_chunk *tc;
2325
2326 if (context == NULL) {
2327 fprintf(file, "talloc no parents for NULL\n");
2328 return;
2329 }
2330
2331 tc = talloc_chunk_from_ptr(context);
2332 fprintf(file, "talloc parents of '%s'\n", talloc_get_name(context));
2333 while (tc) {
2334 fprintf(file, "\t'%s'\n", talloc_get_name(TC_PTR_FROM_CHUNK(tc)));
2335 while (tc && tc->prev) tc = tc->prev;
2336 if (tc) {
2337 tc = tc->parent;
2338 }
2339 }
2340 fflush(file);
2341}
2342
2343/*
2344 return 1 if ptr is a parent of context
2345*/
2346static int _talloc_is_parent(const void *context, const void *ptr, int depth)
2347{
2348 struct talloc_chunk *tc;
2349
2350 if (context == NULL) {
2351 return 0;
2352 }
2353
2354 tc = talloc_chunk_from_ptr(context);
2355 while (tc && depth > 0) {
2356 if (TC_PTR_FROM_CHUNK(tc) == ptr) return 1;
2357 while (tc && tc->prev) tc = tc->prev;
2358 if (tc) {
2359 tc = tc->parent;
2360 depth--;
2361 }
2362 }
2363 return 0;
2364}
2365
2366/*
2367 return 1 if ptr is a parent of context
2368*/
2369_PUBLIC_ int talloc_is_parent(const void *context, const void *ptr)
2370{
2371 return _talloc_is_parent(context, ptr, TALLOC_MAX_DEPTH);
2372}
Note: See TracBrowser for help on using the repository browser.