56ad4f75d88b4ecbf7e1505bc8e34ac8a219f673
[sfrench/samba-autobuild/.git] / lib / talloc / talloc.c
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
75 #define TALLOC_MAGIC_REFERENCE ((const char *)1)
76
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() */
79 #ifndef TALLOC_ABORT
80 #define TALLOC_ABORT(reason) abort()
81 #endif
82
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)))
86 #else
87 # define discard_const_p(type, ptr) ((type *)(ptr))
88 #endif
89 #endif
90
91 /* these macros gain us a few percent of speed on gcc */
92 #if (__GNUC__ >= 3)
93 /* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
94    as its first argument */
95 #ifndef likely
96 #define likely(x)   __builtin_expect(!!(x), 1)
97 #endif
98 #ifndef unlikely
99 #define unlikely(x) __builtin_expect(!!(x), 0)
100 #endif
101 #else
102 #ifndef likely
103 #define likely(x) (x)
104 #endif
105 #ifndef unlikely
106 #define unlikely(x) (x)
107 #endif
108 #endif
109
110 /* this null_context is only used if talloc_enable_leak_report() or
111    talloc_enable_leak_report_full() is called, otherwise it remains
112    NULL
113 */
114 static void *null_context;
115 static void *autofree_context;
116
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
119  */
120 static struct {
121         bool initialised;
122         bool enabled;
123         uint8_t fill_value;
124 } talloc_fill;
125
126 #define TALLOC_FILL_ENV "TALLOC_FREE_FILL"
127
128 /*
129  * do not wipe the header, to allow the
130  * double-free logic to still work
131  */
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); \
137         } \
138 } while (0)
139
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); \
146 } while(0)
147 #else
148 #define TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc) do { } while (0)
149 #endif
150
151 #define TC_INVALIDATE_FULL_CHUNK(_tc) do { \
152         TC_INVALIDATE_FULL_FILL_CHUNK(_tc); \
153         TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc); \
154 } while (0)
155
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); \
162         } \
163 } while (0)
164
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); \
172 } while (0)
173 #else
174 #define TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
175 #endif
176
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); \
180 } while (0)
181
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); \
188         } \
189 } while (0)
190
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); \
198 } while (0)
199 #else
200 #define TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
201 #endif
202
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); \
206 } while (0)
207
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); \
216 } while (0)
217 #else
218 #define TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
219 #endif
220
221 #define TC_UNDEFINE_GROW_CHUNK(_tc, _new_size) do { \
222         TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size); \
223 } while (0)
224
225 struct talloc_reference_handle {
226         struct talloc_reference_handle *next, *prev;
227         void *ptr;
228         const char *location;
229 };
230
231 struct talloc_memlimit {
232         struct talloc_chunk *parent;
233         struct talloc_memlimit *upper;
234         size_t max_size;
235         size_t cur_size;
236 };
237
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,
240                                 size_t size);
241 static inline void talloc_memlimit_shrink(struct talloc_memlimit *limit,
242                                 size_t size);
243 static inline void talloc_memlimit_update_on_free(struct talloc_chunk *tc);
244
245 static inline void _talloc_set_name_const(const void *ptr, const char *name);
246
247 typedef int (*talloc_destructor_t)(void *);
248
249 struct talloc_pool_hdr;
250
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;
256         const char *name;
257         size_t size;
258         unsigned flags;
259
260         /*
261          * limit semantics:
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
264          * allocations.
265          * cur_size is used to keep track of the current use
266          */
267         struct talloc_memlimit *limit;
268
269         /*
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
273          * from.
274          */
275         struct talloc_pool_hdr *pool;
276 };
277
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))
282
283 _PUBLIC_ int talloc_version_major(void)
284 {
285         return TALLOC_VERSION_MAJOR;
286 }
287
288 _PUBLIC_ int talloc_version_minor(void)
289 {
290         return TALLOC_VERSION_MINOR;
291 }
292
293 static void (*talloc_log_fn)(const char *message);
294
295 _PUBLIC_ void talloc_set_log_fn(void (*log_fn)(const char *message))
296 {
297         talloc_log_fn = log_fn;
298 }
299
300 static void talloc_log(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);
301 static void talloc_log(const char *fmt, ...)
302 {
303         va_list ap;
304         char *message;
305
306         if (!talloc_log_fn) {
307                 return;
308         }
309
310         va_start(ap, fmt);
311         message = talloc_vasprintf(NULL, fmt, ap);
312         va_end(ap);
313
314         talloc_log_fn(message);
315         talloc_free(message);
316 }
317
318 static void talloc_log_stderr(const char *message)
319 {
320         fprintf(stderr, "%s", message);
321 }
322
323 _PUBLIC_ void talloc_set_log_stderr(void)
324 {
325         talloc_set_log_fn(talloc_log_stderr);
326 }
327
328 static void (*talloc_abort_fn)(const char *reason);
329
330 _PUBLIC_ void talloc_set_abort_fn(void (*abort_fn)(const char *reason))
331 {
332         talloc_abort_fn = abort_fn;
333 }
334
335 static void talloc_abort(const char *reason)
336 {
337         talloc_log("%s\n", reason);
338
339         if (!talloc_abort_fn) {
340                 TALLOC_ABORT(reason);
341         }
342
343         talloc_abort_fn(reason);
344 }
345
346 static void talloc_abort_magic(unsigned magic)
347 {
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",
352                    magic, major, minor,
353                    TALLOC_MAGIC, TALLOC_VERSION_MAJOR, TALLOC_VERSION_MINOR);
354         talloc_abort("Bad talloc magic value - wrong talloc version used/mixed");
355 }
356
357 static void talloc_abort_access_after_free(void)
358 {
359         talloc_abort("Bad talloc magic value - access after free");
360 }
361
362 static void talloc_abort_unknown_value(void)
363 {
364         talloc_abort("Bad talloc magic value - unknown value");
365 }
366
367 /* panic if we get a bad magic value */
368 static inline struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
369 {
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));
375                         return NULL;
376                 }
377
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();
381                         return NULL;
382                 } else {
383                         talloc_abort_unknown_value();
384                         return NULL;
385                 }
386         }
387         return tc;
388 }
389
390 /* hook into the front of the list */
391 #define _TLIST_ADD(list, p) \
392 do { \
393         if (!(list)) { \
394                 (list) = (p); \
395                 (p)->next = (p)->prev = NULL; \
396         } else { \
397                 (list)->prev = (p); \
398                 (p)->next = (list); \
399                 (p)->prev = NULL; \
400                 (list) = (p); \
401         }\
402 } while (0)
403
404 /* remove an element from a list - element doesn't have to be in list. */
405 #define _TLIST_REMOVE(list, p) \
406 do { \
407         if ((p) == (list)) { \
408                 (list) = (p)->next; \
409                 if (list) (list)->prev = NULL; \
410         } else { \
411                 if ((p)->prev) (p)->prev->next = (p)->next; \
412                 if ((p)->next) (p)->next->prev = (p)->prev; \
413         } \
414         if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \
415 } while (0)
416
417
418 /*
419   return the parent chunk of a pointer
420 */
421 static inline struct talloc_chunk *talloc_parent_chunk(const void *ptr)
422 {
423         struct talloc_chunk *tc;
424
425         if (unlikely(ptr == NULL)) {
426                 return NULL;
427         }
428
429         tc = talloc_chunk_from_ptr(ptr);
430         while (tc->prev) tc=tc->prev;
431
432         return tc->parent;
433 }
434
435 _PUBLIC_ void *talloc_parent(const void *ptr)
436 {
437         struct talloc_chunk *tc = talloc_parent_chunk(ptr);
438         return tc? TC_PTR_FROM_CHUNK(tc) : NULL;
439 }
440
441 /*
442   find parents name
443 */
444 _PUBLIC_ const char *talloc_parent_name(const void *ptr)
445 {
446         struct talloc_chunk *tc = talloc_parent_chunk(ptr);
447         return tc? tc->name : NULL;
448 }
449
450 /*
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
456   pool memory.
457
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.
461 */
462
463 struct talloc_pool_hdr {
464         void *end;
465         unsigned int object_count;
466         size_t poolsize;
467 };
468
469 #define TP_HDR_SIZE TC_ALIGN16(sizeof(struct talloc_pool_hdr))
470
471 static inline struct talloc_pool_hdr *talloc_pool_from_chunk(struct talloc_chunk *c)
472 {
473         return (struct talloc_pool_hdr *)((char *)c - TP_HDR_SIZE);
474 }
475
476 static inline struct talloc_chunk *talloc_chunk_from_pool(struct talloc_pool_hdr *h)
477 {
478         return (struct talloc_chunk *)((char *)h + TP_HDR_SIZE);
479 }
480
481 static inline void *tc_pool_end(struct talloc_pool_hdr *pool_hdr)
482 {
483         struct talloc_chunk *tc = talloc_chunk_from_pool(pool_hdr);
484         return (char *)tc + TC_HDR_SIZE + pool_hdr->poolsize;
485 }
486
487 static inline size_t tc_pool_space_left(struct talloc_pool_hdr *pool_hdr)
488 {
489         return (char *)tc_pool_end(pool_hdr) - (char *)pool_hdr->end;
490 }
491
492 /* If tc is inside a pool, this gives the next neighbour. */
493 static inline void *tc_next_chunk(struct talloc_chunk *tc)
494 {
495         return (char *)tc + TC_ALIGN16(TC_HDR_SIZE + tc->size);
496 }
497
498 static inline void *tc_pool_first_chunk(struct talloc_pool_hdr *pool_hdr)
499 {
500         struct talloc_chunk *tc = talloc_chunk_from_pool(pool_hdr);
501         return tc_next_chunk(tc);
502 }
503
504 /* Mark the whole remaining pool as not accessable */
505 static inline void tc_invalidate_pool(struct talloc_pool_hdr *pool_hdr)
506 {
507         size_t flen = tc_pool_space_left(pool_hdr);
508
509         if (unlikely(talloc_fill.enabled)) {
510                 memset(pool_hdr->end, talloc_fill.fill_value, flen);
511         }
512
513 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
514         VALGRIND_MAKE_MEM_NOACCESS(pool_hdr->end, flen);
515 #endif
516 }
517
518 /*
519   Allocate from a pool
520 */
521
522 static inline struct talloc_chunk *talloc_alloc_pool(struct talloc_chunk *parent,
523                                                      size_t size, size_t prefix_len)
524 {
525         struct talloc_pool_hdr *pool_hdr = NULL;
526         size_t space_left;
527         struct talloc_chunk *result;
528         size_t chunk_size;
529
530         if (parent == NULL) {
531                 return NULL;
532         }
533
534         if (parent->flags & TALLOC_FLAG_POOL) {
535                 pool_hdr = talloc_pool_from_chunk(parent);
536         }
537         else if (parent->flags & TALLOC_FLAG_POOLMEM) {
538                 pool_hdr = parent->pool;
539         }
540
541         if (pool_hdr == NULL) {
542                 return NULL;
543         }
544
545         space_left = tc_pool_space_left(pool_hdr);
546
547         /*
548          * Align size to 16 bytes
549          */
550         chunk_size = TC_ALIGN16(size + prefix_len);
551
552         if (space_left < chunk_size) {
553                 return NULL;
554         }
555
556         result = (struct talloc_chunk *)((char *)pool_hdr->end + prefix_len);
557
558 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
559         VALGRIND_MAKE_MEM_UNDEFINED(pool_hdr->end, chunk_size);
560 #endif
561
562         pool_hdr->end = (void *)((char *)pool_hdr->end + chunk_size);
563
564         result->flags = TALLOC_MAGIC | TALLOC_FLAG_POOLMEM;
565         result->pool = pool_hdr;
566
567         pool_hdr->object_count++;
568
569         return result;
570 }
571
572 /*
573    Allocate a bit of memory as a child of an existing pointer
574 */
575 static inline void *__talloc_with_prefix(const void *context, size_t size,
576                                         size_t prefix_len)
577 {
578         struct talloc_chunk *tc = NULL;
579         struct talloc_memlimit *limit = NULL;
580         size_t total_len = TC_HDR_SIZE + size + prefix_len;
581
582         if (unlikely(context == NULL)) {
583                 context = null_context;
584         }
585
586         if (unlikely(size >= MAX_TALLOC_SIZE)) {
587                 return NULL;
588         }
589
590         if (unlikely(total_len < TC_HDR_SIZE)) {
591                 return NULL;
592         }
593
594         if (context != NULL) {
595                 struct talloc_chunk *ptc = talloc_chunk_from_ptr(context);
596
597                 if (ptc->limit != NULL) {
598                         limit = ptc->limit;
599                 }
600
601                 tc = talloc_alloc_pool(ptc, TC_HDR_SIZE+size, prefix_len);
602         }
603
604         if (tc == NULL) {
605                 char *ptr;
606
607                 /*
608                  * Only do the memlimit check/update on actual allocation.
609                  */
610                 if (!talloc_memlimit_check(limit, total_len)) {
611                         errno = ENOMEM;
612                         return NULL;
613                 }
614
615                 ptr = malloc(total_len);
616                 if (unlikely(ptr == NULL)) {
617                         return NULL;
618                 }
619                 tc = (struct talloc_chunk *)(ptr + prefix_len);
620                 tc->flags = TALLOC_MAGIC;
621                 tc->pool  = NULL;
622
623                 talloc_memlimit_grow(limit, total_len);
624         }
625
626         tc->limit = limit;
627         tc->size = size;
628         tc->destructor = NULL;
629         tc->child = NULL;
630         tc->name = NULL;
631         tc->refs = NULL;
632
633         if (likely(context)) {
634                 struct talloc_chunk *parent = talloc_chunk_from_ptr(context);
635
636                 if (parent->child) {
637                         parent->child->parent = NULL;
638                         tc->next = parent->child;
639                         tc->next->prev = tc;
640                 } else {
641                         tc->next = NULL;
642                 }
643                 tc->parent = parent;
644                 tc->prev = NULL;
645                 parent->child = tc;
646         } else {
647                 tc->next = tc->prev = tc->parent = NULL;
648         }
649
650         return TC_PTR_FROM_CHUNK(tc);
651 }
652
653 static inline void *__talloc(const void *context, size_t size)
654 {
655         return __talloc_with_prefix(context, size, 0);
656 }
657
658 /*
659  * Create a talloc pool
660  */
661
662 static inline void *_talloc_pool(const void *context, size_t size)
663 {
664         struct talloc_chunk *tc;
665         struct talloc_pool_hdr *pool_hdr;
666         void *result;
667
668         result = __talloc_with_prefix(context, size, TP_HDR_SIZE);
669
670         if (unlikely(result == NULL)) {
671                 return NULL;
672         }
673
674         tc = talloc_chunk_from_ptr(result);
675         pool_hdr = talloc_pool_from_chunk(tc);
676
677         tc->flags |= TALLOC_FLAG_POOL;
678         tc->size = 0;
679
680         pool_hdr->object_count = 1;
681         pool_hdr->end = result;
682         pool_hdr->poolsize = size;
683
684         tc_invalidate_pool(pool_hdr);
685
686         return result;
687 }
688
689 _PUBLIC_ void *talloc_pool(const void *context, size_t size)
690 {
691         return _talloc_pool(context, size);
692 }
693
694 /*
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.
698  */
699
700 _PUBLIC_ void *_talloc_pooled_object(const void *ctx,
701                                      size_t type_size,
702                                      const char *type_name,
703                                      unsigned num_subobjects,
704                                      size_t total_subobjects_size)
705 {
706         size_t poolsize, subobjects_slack, tmp;
707         struct talloc_chunk *tc;
708         struct talloc_pool_hdr *pool_hdr;
709         void *ret;
710
711         poolsize = type_size + total_subobjects_size;
712
713         if ((poolsize < type_size) || (poolsize < total_subobjects_size)) {
714                 goto overflow;
715         }
716
717         if (num_subobjects == UINT_MAX) {
718                 goto overflow;
719         }
720         num_subobjects += 1;       /* the object body itself */
721
722         /*
723          * Alignment can increase the pool size by at most 15 bytes per object
724          * plus alignment for the object itself
725          */
726         subobjects_slack = (TC_HDR_SIZE + TP_HDR_SIZE + 15) * num_subobjects;
727         if (subobjects_slack < num_subobjects) {
728                 goto overflow;
729         }
730
731         tmp = poolsize + subobjects_slack;
732         if ((tmp < poolsize) || (tmp < subobjects_slack)) {
733                 goto overflow;
734         }
735         poolsize = tmp;
736
737         ret = _talloc_pool(ctx, poolsize);
738         if (ret == NULL) {
739                 return NULL;
740         }
741
742         tc = talloc_chunk_from_ptr(ret);
743         tc->size = type_size;
744
745         pool_hdr = talloc_pool_from_chunk(tc);
746
747 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
748         VALGRIND_MAKE_MEM_UNDEFINED(pool_hdr->end, type_size);
749 #endif
750
751         pool_hdr->end = ((char *)pool_hdr->end + TC_ALIGN16(type_size));
752
753         _talloc_set_name_const(ret, type_name);
754         return ret;
755
756 overflow:
757         return NULL;
758 }
759
760 /*
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
765 */
766 _PUBLIC_ void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
767 {
768         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
769         tc->destructor = destructor;
770 }
771
772 /*
773   increase the reference count on a piece of memory.
774 */
775 _PUBLIC_ int talloc_increase_ref_count(const void *ptr)
776 {
777         if (unlikely(!talloc_reference(null_context, ptr))) {
778                 return -1;
779         }
780         return 0;
781 }
782
783 /*
784   helper for talloc_reference()
785
786   this is referenced by a function pointer and should not be inline
787 */
788 static int talloc_reference_destructor(struct talloc_reference_handle *handle)
789 {
790         struct talloc_chunk *ptr_tc = talloc_chunk_from_ptr(handle->ptr);
791         _TLIST_REMOVE(ptr_tc->refs, handle);
792         return 0;
793 }
794
795 /*
796    more efficient way to add a name to a pointer - the name must point to a
797    true string constant
798 */
799 static inline void _talloc_set_name_const(const void *ptr, const char *name)
800 {
801         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
802         tc->name = name;
803 }
804
805 /*
806   internal talloc_named_const()
807 */
808 static inline void *_talloc_named_const(const void *context, size_t size, const char *name)
809 {
810         void *ptr;
811
812         ptr = __talloc(context, size);
813         if (unlikely(ptr == NULL)) {
814                 return NULL;
815         }
816
817         _talloc_set_name_const(ptr, name);
818
819         return ptr;
820 }
821
822 /*
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
825   context are freed.
826
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,
829   and in either order
830 */
831 _PUBLIC_ void *_talloc_reference_loc(const void *context, const void *ptr, const char *location)
832 {
833         struct talloc_chunk *tc;
834         struct talloc_reference_handle *handle;
835         if (unlikely(ptr == NULL)) return NULL;
836
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;
842
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);
850         return handle->ptr;
851 }
852
853 static void *_talloc_steal_internal(const void *new_ctx, const void *ptr);
854
855 static inline void _talloc_free_poolmem(struct talloc_chunk *tc,
856                                         const char *location)
857 {
858         struct talloc_pool_hdr *pool;
859         struct talloc_chunk *pool_tc;
860         void *next_tc;
861
862         pool = tc->pool;
863         pool_tc = talloc_chunk_from_pool(pool);
864         next_tc = tc_next_chunk(tc);
865
866         tc->flags |= TALLOC_FLAG_FREE;
867
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
871          */
872         tc->name = location;
873
874         TC_INVALIDATE_FULL_CHUNK(tc);
875
876         if (unlikely(pool->object_count == 0)) {
877                 talloc_abort("Pool object count zero!");
878                 return;
879         }
880
881         pool->object_count--;
882
883         if (unlikely(pool->object_count == 1
884                      && !(pool_tc->flags & TALLOC_FLAG_FREE))) {
885                 /*
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
890                  * again.
891                  */
892                 pool->end = tc_pool_first_chunk(pool);
893                 tc_invalidate_pool(pool);
894                 return;
895         }
896
897         if (unlikely(pool->object_count == 0)) {
898                 /*
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
902                  */
903                 pool_tc->name = location;
904
905                 if (pool_tc->flags & TALLOC_FLAG_POOLMEM) {
906                         _talloc_free_poolmem(pool_tc, location);
907                 } else {
908                         /*
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.
913                          */
914                         talloc_memlimit_update_on_free(pool_tc);
915                         TC_INVALIDATE_FULL_CHUNK(pool_tc);
916                         free(pool);
917                 }
918                 return;
919         }
920
921         if (pool->end == next_tc) {
922                 /*
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'.
926                  */
927                 pool->end = tc;
928                 return;
929         }
930
931         /*
932          * Do nothing. The memory is just "wasted", waiting for the pool
933          * itself to be freed.
934          */
935 }
936
937 static inline void _talloc_free_children_internal(struct talloc_chunk *tc,
938                                                   void *ptr,
939                                                   const char *location);
940
941 /*
942    internal talloc_free call
943 */
944 static inline int _talloc_free_internal(void *ptr, const char *location)
945 {
946         struct talloc_chunk *tc;
947         void *ptr_to_free;
948
949         if (unlikely(ptr == NULL)) {
950                 return -1;
951         }
952
953         /* possibly initialised the talloc fill value */
954         if (unlikely(!talloc_fill.initialised)) {
955                 const char *fill = getenv(TALLOC_FILL_ENV);
956                 if (fill != NULL) {
957                         talloc_fill.enabled = true;
958                         talloc_fill.fill_value = strtoul(fill, NULL, 0);
959                 }
960                 talloc_fill.initialised = true;
961         }
962
963         tc = talloc_chunk_from_ptr(ptr);
964
965         if (unlikely(tc->refs)) {
966                 int is_child;
967                 /* check if this is a reference from a child or
968                  * grandchild back to it's parent or grandparent
969                  *
970                  * in that case we need to remove the reference and
971                  * call another instance of talloc_free() on the current
972                  * pointer.
973                  */
974                 is_child = talloc_is_parent(tc->refs, ptr);
975                 _talloc_free_internal(tc->refs, location);
976                 if (is_child) {
977                         return _talloc_free_internal(ptr, location);
978                 }
979                 return -1;
980         }
981
982         if (unlikely(tc->flags & TALLOC_FLAG_LOOP)) {
983                 /* we have a free loop - stop looping */
984                 return 0;
985         }
986
987         if (unlikely(tc->destructor)) {
988                 talloc_destructor_t d = tc->destructor;
989                 if (d == (talloc_destructor_t)-1) {
990                         return -1;
991                 }
992                 tc->destructor = (talloc_destructor_t)-1;
993                 if (d(ptr) == -1) {
994                         tc->destructor = d;
995                         return -1;
996                 }
997                 tc->destructor = NULL;
998         }
999
1000         if (tc->parent) {
1001                 _TLIST_REMOVE(tc->parent->child, tc);
1002                 if (tc->parent->child) {
1003                         tc->parent->child->parent = tc->parent;
1004                 }
1005         } else {
1006                 if (tc->prev) tc->prev->next = tc->next;
1007                 if (tc->next) tc->next->prev = tc->prev;
1008                 tc->prev = tc->next = NULL;
1009         }
1010
1011         tc->flags |= TALLOC_FLAG_LOOP;
1012
1013         _talloc_free_children_internal(tc, ptr, location);
1014
1015         tc->flags |= TALLOC_FLAG_FREE;
1016
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
1020          */
1021         tc->name = location;
1022
1023         if (tc->flags & TALLOC_FLAG_POOL) {
1024                 struct talloc_pool_hdr *pool;
1025
1026                 pool = talloc_pool_from_chunk(tc);
1027
1028                 if (unlikely(pool->object_count == 0)) {
1029                         talloc_abort("Pool object count zero!");
1030                         return 0;
1031                 }
1032
1033                 pool->object_count--;
1034
1035                 if (likely(pool->object_count != 0)) {
1036                         return 0;
1037                 }
1038
1039                 /*
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.
1043                 */
1044                 ptr_to_free = pool;
1045         } else {
1046                 ptr_to_free = tc;
1047         }
1048
1049         if (tc->flags & TALLOC_FLAG_POOLMEM) {
1050                 _talloc_free_poolmem(tc, location);
1051                 return 0;
1052         }
1053
1054         talloc_memlimit_update_on_free(tc);
1055
1056         TC_INVALIDATE_FULL_CHUNK(tc);
1057         free(ptr_to_free);
1058         return 0;
1059 }
1060
1061 static size_t _talloc_total_limit_size(const void *ptr,
1062                                         struct talloc_memlimit *old_limit,
1063                                         struct talloc_memlimit *new_limit);
1064
1065 /*
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.
1069 */
1070 static void *_talloc_steal_internal(const void *new_ctx, const void *ptr)
1071 {
1072         struct talloc_chunk *tc, *new_tc;
1073         size_t ctx_size = 0;
1074
1075         if (unlikely(!ptr)) {
1076                 return NULL;
1077         }
1078
1079         if (unlikely(new_ctx == NULL)) {
1080                 new_ctx = null_context;
1081         }
1082
1083         tc = talloc_chunk_from_ptr(ptr);
1084
1085         if (tc->limit != NULL) {
1086
1087                 ctx_size = _talloc_total_limit_size(ptr, NULL, NULL);
1088
1089                 /* Decrement the memory limit from the source .. */
1090                 talloc_memlimit_shrink(tc->limit->upper, ctx_size);
1091
1092                 if (tc->limit->parent == tc) {
1093                         tc->limit->upper = NULL;
1094                 } else {
1095                         tc->limit = NULL;
1096                 }
1097         }
1098
1099         if (unlikely(new_ctx == NULL)) {
1100                 if (tc->parent) {
1101                         _TLIST_REMOVE(tc->parent->child, tc);
1102                         if (tc->parent->child) {
1103                                 tc->parent->child->parent = tc->parent;
1104                         }
1105                 } else {
1106                         if (tc->prev) tc->prev->next = tc->next;
1107                         if (tc->next) tc->next->prev = tc->prev;
1108                 }
1109
1110                 tc->parent = tc->next = tc->prev = NULL;
1111                 return discard_const_p(void, ptr);
1112         }
1113
1114         new_tc = talloc_chunk_from_ptr(new_ctx);
1115
1116         if (unlikely(tc == new_tc || tc->parent == new_tc)) {
1117                 return discard_const_p(void, ptr);
1118         }
1119
1120         if (tc->parent) {
1121                 _TLIST_REMOVE(tc->parent->child, tc);
1122                 if (tc->parent->child) {
1123                         tc->parent->child->parent = tc->parent;
1124                 }
1125         } else {
1126                 if (tc->prev) tc->prev->next = tc->next;
1127                 if (tc->next) tc->next->prev = tc->prev;
1128                 tc->prev = tc->next = NULL;
1129         }
1130
1131         tc->parent = new_tc;
1132         if (new_tc->child) new_tc->child->parent = NULL;
1133         _TLIST_ADD(new_tc->child, tc);
1134
1135         if (tc->limit || new_tc->limit) {
1136                 ctx_size = _talloc_total_limit_size(ptr, tc->limit,
1137                                                     new_tc->limit);
1138                 /* .. and increment it in the destination. */
1139                 if (new_tc->limit) {
1140                         talloc_memlimit_grow(new_tc->limit, ctx_size);
1141                 }
1142         }
1143
1144         return discard_const_p(void, ptr);
1145 }
1146
1147 /*
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.
1151 */
1152 _PUBLIC_ void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *location)
1153 {
1154         struct talloc_chunk *tc;
1155
1156         if (unlikely(ptr == NULL)) {
1157                 return NULL;
1158         }
1159
1160         tc = talloc_chunk_from_ptr(ptr);
1161
1162         if (unlikely(tc->refs != NULL) && talloc_parent(ptr) != new_ctx) {
1163                 struct talloc_reference_handle *h;
1164
1165                 talloc_log("WARNING: talloc_steal with references at %s\n",
1166                            location);
1167
1168                 for (h=tc->refs; h; h=h->next) {
1169                         talloc_log("\treference at %s\n",
1170                                    h->location);
1171                 }
1172         }
1173
1174 #if 0
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);
1179         }
1180 #endif
1181
1182         return _talloc_steal_internal(new_ctx, ptr);
1183 }
1184
1185 /*
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)
1189
1190    The old parent can be either a reference or a parent
1191 */
1192 _PUBLIC_ void *talloc_reparent(const void *old_parent, const void *new_parent, const void *ptr)
1193 {
1194         struct talloc_chunk *tc;
1195         struct talloc_reference_handle *h;
1196
1197         if (unlikely(ptr == NULL)) {
1198                 return NULL;
1199         }
1200
1201         if (old_parent == talloc_parent(ptr)) {
1202                 return _talloc_steal_internal(new_parent, ptr);
1203         }
1204
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) {
1209                                 return NULL;
1210                         }
1211                         return discard_const_p(void, ptr);
1212                 }
1213         }
1214
1215         /* it wasn't a parent */
1216         return NULL;
1217 }
1218
1219 /*
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()
1223 */
1224 static inline int talloc_unreference(const void *context, const void *ptr)
1225 {
1226         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1227         struct talloc_reference_handle *h;
1228
1229         if (unlikely(context == NULL)) {
1230                 context = null_context;
1231         }
1232
1233         for (h=tc->refs;h;h=h->next) {
1234                 struct talloc_chunk *p = talloc_parent_chunk(h);
1235                 if (p == NULL) {
1236                         if (context == NULL) break;
1237                 } else if (TC_PTR_FROM_CHUNK(p) == context) {
1238                         break;
1239                 }
1240         }
1241         if (h == NULL) {
1242                 return -1;
1243         }
1244
1245         return _talloc_free_internal(h, __location__);
1246 }
1247
1248 /*
1249   remove a specific parent context from a pointer. This is a more
1250   controlled variant of talloc_free()
1251 */
1252 _PUBLIC_ int talloc_unlink(const void *context, void *ptr)
1253 {
1254         struct talloc_chunk *tc_p, *new_p, *tc_c;
1255         void *new_parent;
1256
1257         if (ptr == NULL) {
1258                 return -1;
1259         }
1260
1261         if (context == NULL) {
1262                 context = null_context;
1263         }
1264
1265         if (talloc_unreference(context, ptr) == 0) {
1266                 return 0;
1267         }
1268
1269         if (context != NULL) {
1270                 tc_c = talloc_chunk_from_ptr(context);
1271         } else {
1272                 tc_c = NULL;
1273         }
1274         if (tc_c != talloc_parent_chunk(ptr)) {
1275                 return -1;
1276         }
1277
1278         tc_p = talloc_chunk_from_ptr(ptr);
1279
1280         if (tc_p->refs == NULL) {
1281                 return _talloc_free_internal(ptr, __location__);
1282         }
1283
1284         new_p = talloc_parent_chunk(tc_p->refs);
1285         if (new_p) {
1286                 new_parent = TC_PTR_FROM_CHUNK(new_p);
1287         } else {
1288                 new_parent = NULL;
1289         }
1290
1291         if (talloc_unreference(new_parent, ptr) != 0) {
1292                 return -1;
1293         }
1294
1295         _talloc_steal_internal(new_parent, ptr);
1296
1297         return 0;
1298 }
1299
1300 /*
1301   add a name to an existing pointer - va_list version
1302 */
1303 static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
1304
1305 static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
1306 {
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");
1311         }
1312         return tc->name;
1313 }
1314
1315 /*
1316   add a name to an existing pointer
1317 */
1318 _PUBLIC_ const char *talloc_set_name(const void *ptr, const char *fmt, ...)
1319 {
1320         const char *name;
1321         va_list ap;
1322         va_start(ap, fmt);
1323         name = talloc_set_name_v(ptr, fmt, ap);
1324         va_end(ap);
1325         return name;
1326 }
1327
1328
1329 /*
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.
1333 */
1334 _PUBLIC_ void *talloc_named(const void *context, size_t size, const char *fmt, ...)
1335 {
1336         va_list ap;
1337         void *ptr;
1338         const char *name;
1339
1340         ptr = __talloc(context, size);
1341         if (unlikely(ptr == NULL)) return NULL;
1342
1343         va_start(ap, fmt);
1344         name = talloc_set_name_v(ptr, fmt, ap);
1345         va_end(ap);
1346
1347         if (unlikely(name == NULL)) {
1348                 _talloc_free_internal(ptr, __location__);
1349                 return NULL;
1350         }
1351
1352         return ptr;
1353 }
1354
1355 /*
1356   return the name of a talloc ptr, or "UNNAMED"
1357 */
1358 _PUBLIC_ const char *talloc_get_name(const void *ptr)
1359 {
1360         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1361         if (unlikely(tc->name == TALLOC_MAGIC_REFERENCE)) {
1362                 return ".reference";
1363         }
1364         if (likely(tc->name)) {
1365                 return tc->name;
1366         }
1367         return "UNNAMED";
1368 }
1369
1370
1371 /*
1372   check if a pointer has the given name. If it does, return the pointer,
1373   otherwise return NULL
1374 */
1375 _PUBLIC_ void *talloc_check_name(const void *ptr, const char *name)
1376 {
1377         const char *pname;
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);
1382         }
1383         return NULL;
1384 }
1385
1386 static void talloc_abort_type_mismatch(const char *location,
1387                                         const char *name,
1388                                         const char *expected)
1389 {
1390         const char *reason;
1391
1392         reason = talloc_asprintf(NULL,
1393                                  "%s: Type mismatch: name[%s] expected[%s]",
1394                                  location,
1395                                  name?name:"NULL",
1396                                  expected);
1397         if (!reason) {
1398                 reason = "Type mismatch";
1399         }
1400
1401         talloc_abort(reason);
1402 }
1403
1404 _PUBLIC_ void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location)
1405 {
1406         const char *pname;
1407
1408         if (unlikely(ptr == NULL)) {
1409                 talloc_abort_type_mismatch(location, NULL, name);
1410                 return NULL;
1411         }
1412
1413         pname = talloc_get_name(ptr);
1414         if (likely(pname == name || strcmp(pname, name) == 0)) {
1415                 return discard_const_p(void, ptr);
1416         }
1417
1418         talloc_abort_type_mismatch(location, pname, name);
1419         return NULL;
1420 }
1421
1422 /*
1423   this is for compatibility with older versions of talloc
1424 */
1425 _PUBLIC_ void *talloc_init(const char *fmt, ...)
1426 {
1427         va_list ap;
1428         void *ptr;
1429         const char *name;
1430
1431         ptr = __talloc(NULL, 0);
1432         if (unlikely(ptr == NULL)) return NULL;
1433
1434         va_start(ap, fmt);
1435         name = talloc_set_name_v(ptr, fmt, ap);
1436         va_end(ap);
1437
1438         if (unlikely(name == NULL)) {
1439                 _talloc_free_internal(ptr, __location__);
1440                 return NULL;
1441         }
1442
1443         return ptr;
1444 }
1445
1446 static inline void _talloc_free_children_internal(struct talloc_chunk *tc,
1447                                                   void *ptr,
1448                                                   const char *location)
1449 {
1450         while (tc->child) {
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);
1461                 }
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);
1466                         }
1467                         _talloc_steal_internal(new_parent, child);
1468                 }
1469         }
1470 }
1471
1472 /*
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.
1476 */
1477 _PUBLIC_ void talloc_free_children(void *ptr)
1478 {
1479         struct talloc_chunk *tc_name = NULL;
1480         struct talloc_chunk *tc;
1481
1482         if (unlikely(ptr == NULL)) {
1483                 return;
1484         }
1485
1486         tc = talloc_chunk_from_ptr(ptr);
1487
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;
1492                 }
1493                 if (tc_name) {
1494                         _TLIST_REMOVE(tc->child, tc_name);
1495                         if (tc->child) {
1496                                 tc->child->parent = tc;
1497                         }
1498                 }
1499         }
1500
1501         _talloc_free_children_internal(tc, ptr, __location__);
1502
1503         /* .. so we put it back after all other children have been freed */
1504         if (tc_name) {
1505                 if (tc->child) {
1506                         tc->child->parent = NULL;
1507                 }
1508                 tc_name->parent = tc;
1509                 _TLIST_ADD(tc->child, tc_name);
1510         }
1511 }
1512
1513 /*
1514    Allocate a bit of memory as a child of an existing pointer
1515 */
1516 _PUBLIC_ void *_talloc(const void *context, size_t size)
1517 {
1518         return __talloc(context, size);
1519 }
1520
1521 /*
1522   externally callable talloc_set_name_const()
1523 */
1524 _PUBLIC_ void talloc_set_name_const(const void *ptr, const char *name)
1525 {
1526         _talloc_set_name_const(ptr, name);
1527 }
1528
1529 /*
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.
1533 */
1534 _PUBLIC_ void *talloc_named_const(const void *context, size_t size, const char *name)
1535 {
1536         return _talloc_named_const(context, size, name);
1537 }
1538
1539 /*
1540    free a talloc pointer. This also frees all child pointers of this
1541    pointer recursively
1542
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
1546 */
1547 _PUBLIC_ int _talloc_free(void *ptr, const char *location)
1548 {
1549         struct talloc_chunk *tc;
1550
1551         if (unlikely(ptr == NULL)) {
1552                 return -1;
1553         }
1554
1555         tc = talloc_chunk_from_ptr(ptr);
1556
1557         if (unlikely(tc->refs != NULL)) {
1558                 struct talloc_reference_handle *h;
1559
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
1563                            one parent */
1564                         return talloc_unlink(null_context, ptr);
1565                 }
1566
1567                 talloc_log("ERROR: talloc_free with references at %s\n",
1568                            location);
1569
1570                 for (h=tc->refs; h; h=h->next) {
1571                         talloc_log("\treference at %s\n",
1572                                    h->location);
1573                 }
1574                 return -1;
1575         }
1576
1577         return _talloc_free_internal(ptr, location);
1578 }
1579
1580
1581
1582 /*
1583   A talloc version of realloc. The context argument is only used if
1584   ptr is NULL
1585 */
1586 _PUBLIC_ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name)
1587 {
1588         struct talloc_chunk *tc;
1589         void *new_ptr;
1590         bool malloced = false;
1591         struct talloc_pool_hdr *pool_hdr = NULL;
1592         size_t old_size = 0;
1593         size_t new_size = 0;
1594
1595         /* size zero is equivalent to free() */
1596         if (unlikely(size == 0)) {
1597                 talloc_unlink(context, ptr);
1598                 return NULL;
1599         }
1600
1601         if (unlikely(size >= MAX_TALLOC_SIZE)) {
1602                 return NULL;
1603         }
1604
1605         /* realloc(NULL) is equivalent to malloc() */
1606         if (ptr == NULL) {
1607                 return _talloc_named_const(context, size, name);
1608         }
1609
1610         tc = talloc_chunk_from_ptr(ptr);
1611
1612         /* don't allow realloc on referenced pointers */
1613         if (unlikely(tc->refs)) {
1614                 return NULL;
1615         }
1616
1617         /* don't let anybody try to realloc a talloc_pool */
1618         if (unlikely(tc->flags & TALLOC_FLAG_POOL)) {
1619                 return NULL;
1620         }
1621
1622         if (tc->limit && (size > tc->size)) {
1623                 if (!talloc_memlimit_check(tc->limit, (size - tc->size))) {
1624                         errno = ENOMEM;
1625                         return NULL;
1626                 }
1627         }
1628
1629         /* handle realloc inside a talloc_pool */
1630         if (unlikely(tc->flags & TALLOC_FLAG_POOLMEM)) {
1631                 pool_hdr = tc->pool;
1632         }
1633
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) {
1637                 if (pool_hdr) {
1638                         void *next_tc = tc_next_chunk(tc);
1639                         TC_INVALIDATE_SHRINK_CHUNK(tc, size);
1640                         tc->size = 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);
1644                         }
1645                         return ptr;
1646                 } else if ((tc->size - size) < 1024) {
1647                         /*
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 :-(.
1652                          *
1653                          * That is why we only mark memory as undefined here.
1654                          */
1655                         TC_UNDEFINE_SHRINK_CHUNK(tc, size);
1656
1657                         /* do not shrink if we have less than 1k to gain */
1658                         tc->size = size;
1659                         return ptr;
1660                 }
1661         } else if (tc->size == size) {
1662                 /*
1663                  * do not change the pointer if it is exactly
1664                  * the same size.
1665                  */
1666                 return ptr;
1667         }
1668 #endif
1669
1670         /* by resetting magic we catch users of the old memory */
1671         tc->flags |= TALLOC_FLAG_FREE;
1672
1673 #if ALWAYS_REALLOC
1674         if (pool_hdr) {
1675                 new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE, 0);
1676                 pool_hdr->object_count--;
1677
1678                 if (new_ptr == NULL) {
1679                         new_ptr = malloc(TC_HDR_SIZE+size);
1680                         malloced = true;
1681                         new_size = size;
1682                 }
1683
1684                 if (new_ptr) {
1685                         memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE);
1686                         TC_INVALIDATE_FULL_CHUNK(tc);
1687                 }
1688         } else {
1689                 /* We're doing malloc then free here, so record the difference. */
1690                 old_size = tc->size;
1691                 new_size = size;
1692                 new_ptr = malloc(size + TC_HDR_SIZE);
1693                 if (new_ptr) {
1694                         memcpy(new_ptr, tc, MIN(tc->size, size) + TC_HDR_SIZE);
1695                         free(tc);
1696                 }
1697         }
1698 #else
1699         if (pool_hdr) {
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;
1705                 size_t space_left;
1706                 unsigned int chunk_count = pool_hdr->object_count;
1707
1708                 pool_tc = talloc_chunk_from_pool(pool_hdr);
1709                 if (!(pool_tc->flags & TALLOC_FLAG_FREE)) {
1710                         chunk_count -= 1;
1711                 }
1712
1713                 if (chunk_count == 1) {
1714                         /*
1715                          * optimize for the case where 'tc' is the only
1716                          * chunk in the pool.
1717                          */
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;
1721
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;
1725                                 new_ptr = start;
1726
1727 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
1728                                 {
1729                                         /*
1730                                          * The area from
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.
1741                                          */
1742                                         size_t undef_len = MIN((((char *)tc) - ((char *)new_ptr)),old_used);
1743                                         VALGRIND_MAKE_MEM_UNDEFINED(new_ptr, undef_len);
1744                                 }
1745 #endif
1746
1747                                 memmove(new_ptr, tc, old_used);
1748
1749                                 tc = (struct talloc_chunk *)new_ptr;
1750                                 TC_UNDEFINE_GROW_CHUNK(tc, size);
1751
1752                                 /*
1753                                  * first we do not align the pool pointer
1754                                  * because we want to invalidate the padding
1755                                  * too.
1756                                  */
1757                                 pool_hdr->end = new_used + (char *)new_ptr;
1758                                 tc_invalidate_pool(pool_hdr);
1759
1760                                 /* now the aligned pointer */
1761                                 pool_hdr->end = new_chunk_size + (char *)new_ptr;
1762                                 goto got_new_ptr;
1763                         }
1764
1765                         next_tc = NULL;
1766                 }
1767
1768                 if (new_chunk_size == old_chunk_size) {
1769                         TC_UNDEFINE_GROW_CHUNK(tc, size);
1770                         tc->flags &= ~TALLOC_FLAG_FREE;
1771                         tc->size = size;
1772                         return ptr;
1773                 }
1774
1775                 if (next_tc == pool_hdr->end) {
1776                         /*
1777                          * optimize for the case where 'tc' is the last
1778                          * chunk in the pool.
1779                          */
1780                         space_needed = new_chunk_size - old_chunk_size;
1781                         space_left = tc_pool_space_left(pool_hdr);
1782
1783                         if (space_left >= space_needed) {
1784                                 TC_UNDEFINE_GROW_CHUNK(tc, size);
1785                                 tc->flags &= ~TALLOC_FLAG_FREE;
1786                                 tc->size = size;
1787                                 pool_hdr->end = tc_next_chunk(tc);
1788                                 return ptr;
1789                         }
1790                 }
1791
1792                 new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE, 0);
1793
1794                 if (new_ptr == NULL) {
1795                         new_ptr = malloc(TC_HDR_SIZE+size);
1796                         malloced = true;
1797                         new_size = size;
1798                 }
1799
1800                 if (new_ptr) {
1801                         memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE);
1802
1803                         _talloc_free_poolmem(tc, __location__ "_talloc_realloc");
1804                 }
1805         }
1806         else {
1807                 /* We're doing realloc here, so record the difference. */
1808                 old_size = tc->size;
1809                 new_size = size;
1810                 new_ptr = realloc(tc, size + TC_HDR_SIZE);
1811         }
1812 got_new_ptr:
1813 #endif
1814         if (unlikely(!new_ptr)) {
1815                 tc->flags &= ~TALLOC_FLAG_FREE;
1816                 return NULL;
1817         }
1818
1819         tc = (struct talloc_chunk *)new_ptr;
1820         tc->flags &= ~TALLOC_FLAG_FREE;
1821         if (malloced) {
1822                 tc->flags &= ~TALLOC_FLAG_POOLMEM;
1823         }
1824         if (tc->parent) {
1825                 tc->parent->child = tc;
1826         }
1827         if (tc->child) {
1828                 tc->child->parent = tc;
1829         }
1830
1831         if (tc->prev) {
1832                 tc->prev->next = tc;
1833         }
1834         if (tc->next) {
1835                 tc->next->prev = tc;
1836         }
1837
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);
1842         }
1843
1844         tc->size = size;
1845         _talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
1846
1847         return TC_PTR_FROM_CHUNK(tc);
1848 }
1849
1850 /*
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
1853 */
1854 _PUBLIC_ void *_talloc_move(const void *new_ctx, const void *_pptr)
1855 {
1856         const void **pptr = discard_const_p(const void *,_pptr);
1857         void *ret = talloc_steal(new_ctx, discard_const_p(void, *pptr));
1858         (*pptr) = NULL;
1859         return ret;
1860 }
1861
1862 enum talloc_mem_count_type {
1863         TOTAL_MEM_SIZE,
1864         TOTAL_MEM_BLOCKS,
1865         TOTAL_MEM_LIMIT,
1866 };
1867
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)
1872 {
1873         size_t total = 0;
1874         struct talloc_chunk *c, *tc;
1875
1876         if (ptr == NULL) {
1877                 ptr = null_context;
1878         }
1879         if (ptr == NULL) {
1880                 return 0;
1881         }
1882
1883         tc = talloc_chunk_from_ptr(ptr);
1884
1885         if (old_limit || new_limit) {
1886                 if (tc->limit && tc->limit->upper == old_limit) {
1887                         tc->limit->upper = new_limit;
1888                 }
1889         }
1890
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;
1897         }
1898
1899         if (tc->flags & TALLOC_FLAG_LOOP) {
1900                 return 0;
1901         }
1902
1903         tc->flags |= TALLOC_FLAG_LOOP;
1904
1905         if (old_limit || new_limit) {
1906                 if (old_limit == tc->limit) {
1907                         tc->limit = new_limit;
1908                 }
1909         }
1910
1911         switch (type) {
1912         case TOTAL_MEM_SIZE:
1913                 if (likely(tc->name != TALLOC_MAGIC_REFERENCE)) {
1914                         total = tc->size;
1915                 }
1916                 break;
1917         case TOTAL_MEM_BLOCKS:
1918                 total++;
1919                 break;
1920         case TOTAL_MEM_LIMIT:
1921                 if (likely(tc->name != TALLOC_MAGIC_REFERENCE)) {
1922                         /*
1923                          * Don't count memory allocated from a pool
1924                          * when calculating limits. Only count the
1925                          * pool itself.
1926                          */
1927                         if (!(tc->flags & TALLOC_FLAG_POOLMEM)) {
1928                                 if (tc->flags & TALLOC_FLAG_POOL) {
1929                                         /*
1930                                          * If this is a pool, the allocated
1931                                          * size is in the pool header, and
1932                                          * remember to add in the prefix
1933                                          * length.
1934                                          */
1935                                         struct talloc_pool_hdr *pool_hdr
1936                                                         = talloc_pool_from_chunk(tc);
1937                                         total = pool_hdr->poolsize +
1938                                                         TC_HDR_SIZE +
1939                                                         TP_HDR_SIZE;
1940                                 } else {
1941                                         total = tc->size + TC_HDR_SIZE;
1942                                 }
1943                         }
1944                 }
1945                 break;
1946         }
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);
1950         }
1951
1952         tc->flags &= ~TALLOC_FLAG_LOOP;
1953
1954         return total;
1955 }
1956
1957 /*
1958   return the total size of a talloc pool (subtree)
1959 */
1960 _PUBLIC_ size_t talloc_total_size(const void *ptr)
1961 {
1962         return _talloc_total_mem_internal(ptr, TOTAL_MEM_SIZE, NULL, NULL);
1963 }
1964
1965 /*
1966   return the total number of blocks in a talloc pool (subtree)
1967 */
1968 _PUBLIC_ size_t talloc_total_blocks(const void *ptr)
1969 {
1970         return _talloc_total_mem_internal(ptr, TOTAL_MEM_BLOCKS, NULL, NULL);
1971 }
1972
1973 /*
1974   return the number of external references to a pointer
1975 */
1976 _PUBLIC_ size_t talloc_reference_count(const void *ptr)
1977 {
1978         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1979         struct talloc_reference_handle *h;
1980         size_t ret = 0;
1981
1982         for (h=tc->refs;h;h=h->next) {
1983                 ret++;
1984         }
1985         return ret;
1986 }
1987
1988 /*
1989   report on memory usage by all children of a pointer, giving a full tree view
1990 */
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,
1994                                              int is_ref,
1995                                              void *private_data),
1996                             void *private_data)
1997 {
1998         struct talloc_chunk *c, *tc;
1999
2000         if (ptr == NULL) {
2001                 ptr = null_context;
2002         }
2003         if (ptr == NULL) return;
2004
2005         tc = talloc_chunk_from_ptr(ptr);
2006
2007         if (tc->flags & TALLOC_FLAG_LOOP) {
2008                 return;
2009         }
2010
2011         callback(ptr, depth, max_depth, 0, private_data);
2012
2013         if (max_depth >= 0 && depth >= max_depth) {
2014                 return;
2015         }
2016
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);
2022                 } else {
2023                         talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c), depth + 1, max_depth, callback, private_data);
2024                 }
2025         }
2026         tc->flags &= ~TALLOC_FLAG_LOOP;
2027 }
2028
2029 static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_depth, int is_ref, void *_f)
2030 {
2031         const char *name = talloc_get_name(ptr);
2032         struct talloc_chunk *tc;
2033         FILE *f = (FILE *)_f;
2034
2035         if (is_ref) {
2036                 fprintf(f, "%*sreference to: %s\n", depth*4, "", name);
2037                 return;
2038         }
2039
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",
2044                         depth*4, "",
2045                         name,
2046                         (unsigned long)tc->limit->max_size,
2047                         (unsigned long)tc->limit->cur_size);
2048         }
2049
2050         if (depth == 0) {
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));
2055                 return;
2056         }
2057
2058         fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d) %p\n",
2059                 depth*4, "",
2060                 name,
2061                 (unsigned long)talloc_total_size(ptr),
2062                 (unsigned long)talloc_total_blocks(ptr),
2063                 (int)talloc_reference_count(ptr), ptr);
2064
2065 #if 0
2066         fprintf(f, "content: ");
2067         if (talloc_total_size(ptr)) {
2068                 int tot = talloc_total_size(ptr);
2069                 int i;
2070
2071                 for (i = 0; i < tot; i++) {
2072                         if ((((char *)ptr)[i] > 31) && (((char *)ptr)[i] < 126)) {
2073                                 fprintf(f, "%c", ((char *)ptr)[i]);
2074                         } else {
2075                                 fprintf(f, "~%02x", ((char *)ptr)[i]);
2076                         }
2077                 }
2078         }
2079         fprintf(f, "\n");
2080 #endif
2081 }
2082
2083 /*
2084   report on memory usage by all children of a pointer, giving a full tree view
2085 */
2086 _PUBLIC_ void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f)
2087 {
2088         if (f) {
2089                 talloc_report_depth_cb(ptr, depth, max_depth, talloc_report_depth_FILE_helper, f);
2090                 fflush(f);
2091         }
2092 }
2093
2094 /*
2095   report on memory usage by all children of a pointer, giving a full tree view
2096 */
2097 _PUBLIC_ void talloc_report_full(const void *ptr, FILE *f)
2098 {
2099         talloc_report_depth_file(ptr, 0, -1, f);
2100 }
2101
2102 /*
2103   report on memory usage by all children of a pointer
2104 */
2105 _PUBLIC_ void talloc_report(const void *ptr, FILE *f)
2106 {
2107         talloc_report_depth_file(ptr, 0, 1, f);
2108 }
2109
2110 /*
2111   report on any memory hanging off the null context
2112 */
2113 static void talloc_report_null(void)
2114 {
2115         if (talloc_total_size(null_context) != 0) {
2116                 talloc_report(null_context, stderr);
2117         }
2118 }
2119
2120 /*
2121   report on any memory hanging off the null context
2122 */
2123 static void talloc_report_null_full(void)
2124 {
2125         if (talloc_total_size(null_context) != 0) {
2126                 talloc_report_full(null_context, stderr);
2127         }
2128 }
2129
2130 /*
2131   enable tracking of the NULL context
2132 */
2133 _PUBLIC_ void talloc_enable_null_tracking(void)
2134 {
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);
2139                 }
2140         }
2141 }
2142
2143 /*
2144   enable tracking of the NULL context, not moving the autofree context
2145   into the NULL context. This is needed for the talloc testsuite
2146 */
2147 _PUBLIC_ void talloc_enable_null_tracking_no_autofree(void)
2148 {
2149         if (null_context == NULL) {
2150                 null_context = _talloc_named_const(NULL, 0, "null_context");
2151         }
2152 }
2153
2154 /*
2155   disable tracking of the NULL context
2156 */
2157 _PUBLIC_ void talloc_disable_null_tracking(void)
2158 {
2159         if (null_context != NULL) {
2160                 /* we have to move any children onto the real NULL
2161                    context */
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;
2167                 }
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;
2171                 }
2172                 tc->child = NULL;
2173                 tc->next = NULL;
2174         }
2175         talloc_free(null_context);
2176         null_context = NULL;
2177 }
2178
2179 /*
2180   enable leak reporting on exit
2181 */
2182 _PUBLIC_ void talloc_enable_leak_report(void)
2183 {
2184         talloc_enable_null_tracking();
2185         atexit(talloc_report_null);
2186 }
2187
2188 /*
2189   enable full leak reporting on exit
2190 */
2191 _PUBLIC_ void talloc_enable_leak_report_full(void)
2192 {
2193         talloc_enable_null_tracking();
2194         atexit(talloc_report_null_full);
2195 }
2196
2197 /*
2198    talloc and zero memory.
2199 */
2200 _PUBLIC_ void *_talloc_zero(const void *ctx, size_t size, const char *name)
2201 {
2202         void *p = _talloc_named_const(ctx, size, name);
2203
2204         if (p) {
2205                 memset(p, '\0', size);
2206         }
2207
2208         return p;
2209 }
2210
2211 /*
2212   memdup with a talloc.
2213 */
2214 _PUBLIC_ void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
2215 {
2216         void *newp = _talloc_named_const(t, size, name);
2217
2218         if (likely(newp)) {
2219                 memcpy(newp, p, size);
2220         }
2221
2222         return newp;
2223 }
2224
2225 static inline char *__talloc_strlendup(const void *t, const char *p, size_t len)
2226 {
2227         char *ret;
2228
2229         ret = (char *)__talloc(t, len + 1);
2230         if (unlikely(!ret)) return NULL;
2231
2232         memcpy(ret, p, len);
2233         ret[len] = 0;
2234
2235         _talloc_set_name_const(ret, ret);
2236         return ret;
2237 }
2238
2239 /*
2240   strdup with a talloc
2241 */
2242 _PUBLIC_ char *talloc_strdup(const void *t, const char *p)
2243 {
2244         if (unlikely(!p)) return NULL;
2245         return __talloc_strlendup(t, p, strlen(p));
2246 }
2247
2248 /*
2249   strndup with a talloc
2250 */
2251 _PUBLIC_ char *talloc_strndup(const void *t, const char *p, size_t n)
2252 {
2253         if (unlikely(!p)) return NULL;
2254         return __talloc_strlendup(t, p, strnlen(p, n));
2255 }
2256
2257 static inline char *__talloc_strlendup_append(char *s, size_t slen,
2258                                               const char *a, size_t alen)
2259 {
2260         char *ret;
2261
2262         ret = talloc_realloc(NULL, s, char, slen + alen + 1);
2263         if (unlikely(!ret)) return NULL;
2264
2265         /* append the string and the trailing \0 */
2266         memcpy(&ret[slen], a, alen);
2267         ret[slen+alen] = 0;
2268
2269         _talloc_set_name_const(ret, ret);
2270         return ret;
2271 }
2272
2273 /*
2274  * Appends at the end of the string.
2275  */
2276 _PUBLIC_ char *talloc_strdup_append(char *s, const char *a)
2277 {
2278         if (unlikely(!s)) {
2279                 return talloc_strdup(NULL, a);
2280         }
2281
2282         if (unlikely(!a)) {
2283                 return s;
2284         }
2285
2286         return __talloc_strlendup_append(s, strlen(s), a, strlen(a));
2287 }
2288
2289 /*
2290  * Appends at the end of the talloc'ed buffer,
2291  * not the end of the string.
2292  */
2293 _PUBLIC_ char *talloc_strdup_append_buffer(char *s, const char *a)
2294 {
2295         size_t slen;
2296
2297         if (unlikely(!s)) {
2298                 return talloc_strdup(NULL, a);
2299         }
2300
2301         if (unlikely(!a)) {
2302                 return s;
2303         }
2304
2305         slen = talloc_get_size(s);
2306         if (likely(slen > 0)) {
2307                 slen--;
2308         }
2309
2310         return __talloc_strlendup_append(s, slen, a, strlen(a));
2311 }
2312
2313 /*
2314  * Appends at the end of the string.
2315  */
2316 _PUBLIC_ char *talloc_strndup_append(char *s, const char *a, size_t n)
2317 {
2318         if (unlikely(!s)) {
2319                 return talloc_strndup(NULL, a, n);
2320         }
2321
2322         if (unlikely(!a)) {
2323                 return s;
2324         }
2325
2326         return __talloc_strlendup_append(s, strlen(s), a, strnlen(a, n));
2327 }
2328
2329 /*
2330  * Appends at the end of the talloc'ed buffer,
2331  * not the end of the string.
2332  */
2333 _PUBLIC_ char *talloc_strndup_append_buffer(char *s, const char *a, size_t n)
2334 {
2335         size_t slen;
2336
2337         if (unlikely(!s)) {
2338                 return talloc_strndup(NULL, a, n);
2339         }
2340
2341         if (unlikely(!a)) {
2342                 return s;
2343         }
2344
2345         slen = talloc_get_size(s);
2346         if (likely(slen > 0)) {
2347                 slen--;
2348         }
2349
2350         return __talloc_strlendup_append(s, slen, a, strnlen(a, n));
2351 }
2352
2353 #ifndef HAVE_VA_COPY
2354 #ifdef HAVE___VA_COPY
2355 #define va_copy(dest, src) __va_copy(dest, src)
2356 #else
2357 #define va_copy(dest, src) (dest) = (src)
2358 #endif
2359 #endif
2360
2361 _PUBLIC_ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
2362 {
2363         int len;
2364         char *ret;
2365         va_list ap2;
2366         char buf[1024];
2367
2368         /* this call looks strange, but it makes it work on older solaris boxes */
2369         va_copy(ap2, ap);
2370         len = vsnprintf(buf, sizeof(buf), fmt, ap2);
2371         va_end(ap2);
2372         if (unlikely(len < 0)) {
2373                 return NULL;
2374         }
2375
2376         ret = (char *)__talloc(t, len+1);
2377         if (unlikely(!ret)) return NULL;
2378
2379         if (len < sizeof(buf)) {
2380                 memcpy(ret, buf, len+1);
2381         } else {
2382                 va_copy(ap2, ap);
2383                 vsnprintf(ret, len+1, fmt, ap2);
2384                 va_end(ap2);
2385         }
2386
2387         _talloc_set_name_const(ret, ret);
2388         return ret;
2389 }
2390
2391
2392 /*
2393   Perform string formatting, and return a pointer to newly allocated
2394   memory holding the result, inside a memory pool.
2395  */
2396 _PUBLIC_ char *talloc_asprintf(const void *t, const char *fmt, ...)
2397 {
2398         va_list ap;
2399         char *ret;
2400
2401         va_start(ap, fmt);
2402         ret = talloc_vasprintf(t, fmt, ap);
2403         va_end(ap);
2404         return ret;
2405 }
2406
2407 static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
2408                                                  const char *fmt, va_list ap)
2409                                                  PRINTF_ATTRIBUTE(3,0);
2410
2411 static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
2412                                                  const char *fmt, va_list ap)
2413 {
2414         ssize_t alen;
2415         va_list ap2;
2416         char c;
2417
2418         va_copy(ap2, ap);
2419         alen = vsnprintf(&c, 1, fmt, ap2);
2420         va_end(ap2);
2421
2422         if (alen <= 0) {
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.
2428                  */
2429                 return s;
2430         }
2431
2432         s = talloc_realloc(NULL, s, char, slen + alen + 1);
2433         if (!s) return NULL;
2434
2435         va_copy(ap2, ap);
2436         vsnprintf(s + slen, alen + 1, fmt, ap2);
2437         va_end(ap2);
2438
2439         _talloc_set_name_const(s, s);
2440         return s;
2441 }
2442
2443 /**
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
2447  * of the string.
2448  **/
2449 _PUBLIC_ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
2450 {
2451         if (unlikely(!s)) {
2452                 return talloc_vasprintf(NULL, fmt, ap);
2453         }
2454
2455         return __talloc_vaslenprintf_append(s, strlen(s), fmt, ap);
2456 }
2457
2458 /**
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.
2462  **/
2463 _PUBLIC_ char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
2464 {
2465         size_t slen;
2466
2467         if (unlikely(!s)) {
2468                 return talloc_vasprintf(NULL, fmt, ap);
2469         }
2470
2471         slen = talloc_get_size(s);
2472         if (likely(slen > 0)) {
2473                 slen--;
2474         }
2475
2476         return __talloc_vaslenprintf_append(s, slen, fmt, ap);
2477 }
2478
2479 /*
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.
2483  */
2484 _PUBLIC_ char *talloc_asprintf_append(char *s, const char *fmt, ...)
2485 {
2486         va_list ap;
2487
2488         va_start(ap, fmt);
2489         s = talloc_vasprintf_append(s, fmt, ap);
2490         va_end(ap);
2491         return s;
2492 }
2493
2494 /*
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
2497   into a buffer.
2498  */
2499 _PUBLIC_ char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...)
2500 {
2501         va_list ap;
2502
2503         va_start(ap, fmt);
2504         s = talloc_vasprintf_append_buffer(s, fmt, ap);
2505         va_end(ap);
2506         return s;
2507 }
2508
2509 /*
2510   alloc an array, checking for integer overflow in the array size
2511 */
2512 _PUBLIC_ void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
2513 {
2514         if (count >= MAX_TALLOC_SIZE/el_size) {
2515                 return NULL;
2516         }
2517         return _talloc_named_const(ctx, el_size * count, name);
2518 }
2519
2520 /*
2521   alloc an zero array, checking for integer overflow in the array size
2522 */
2523 _PUBLIC_ void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
2524 {
2525         if (count >= MAX_TALLOC_SIZE/el_size) {
2526                 return NULL;
2527         }
2528         return _talloc_zero(ctx, el_size * count, name);
2529 }
2530
2531 /*
2532   realloc an array, checking for integer overflow in the array size
2533 */
2534 _PUBLIC_ void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
2535 {
2536         if (count >= MAX_TALLOC_SIZE/el_size) {
2537                 return NULL;
2538         }
2539         return _talloc_realloc(ctx, ptr, el_size * count, name);
2540 }
2541
2542 /*
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)
2546 */
2547 _PUBLIC_ void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
2548 {
2549         return _talloc_realloc(context, ptr, size, NULL);
2550 }
2551
2552
2553 static int talloc_autofree_destructor(void *ptr)
2554 {
2555         autofree_context = NULL;
2556         return 0;
2557 }
2558
2559 static void talloc_autofree(void)
2560 {
2561         talloc_free(autofree_context);
2562 }
2563
2564 /*
2565   return a context which will be auto-freed on exit
2566   this is useful for reducing the noise in leak reports
2567 */
2568 _PUBLIC_ void *talloc_autofree_context(void)
2569 {
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);
2574         }
2575         return autofree_context;
2576 }
2577
2578 _PUBLIC_ size_t talloc_get_size(const void *context)
2579 {
2580         struct talloc_chunk *tc;
2581
2582         if (context == NULL) {
2583                 context = null_context;
2584         }
2585         if (context == NULL) {
2586                 return 0;
2587         }
2588
2589         tc = talloc_chunk_from_ptr(context);
2590
2591         return tc->size;
2592 }
2593
2594 /*
2595   find a parent of this context that has the given name, if any
2596 */
2597 _PUBLIC_ void *talloc_find_parent_byname(const void *context, const char *name)
2598 {
2599         struct talloc_chunk *tc;
2600
2601         if (context == NULL) {
2602                 return NULL;
2603         }
2604
2605         tc = talloc_chunk_from_ptr(context);
2606         while (tc) {
2607                 if (tc->name && strcmp(tc->name, name) == 0) {
2608                         return TC_PTR_FROM_CHUNK(tc);
2609                 }
2610                 while (tc && tc->prev) tc = tc->prev;
2611                 if (tc) {
2612                         tc = tc->parent;
2613                 }
2614         }
2615         return NULL;
2616 }
2617
2618 /*
2619   show the parentage of a context
2620 */
2621 _PUBLIC_ void talloc_show_parents(const void *context, FILE *file)
2622 {
2623         struct talloc_chunk *tc;
2624
2625         if (context == NULL) {
2626                 fprintf(file, "talloc no parents for NULL\n");
2627                 return;
2628         }
2629
2630         tc = talloc_chunk_from_ptr(context);
2631         fprintf(file, "talloc parents of '%s'\n", talloc_get_name(context));
2632         while (tc) {
2633                 fprintf(file, "\t'%s'\n", talloc_get_name(TC_PTR_FROM_CHUNK(tc)));
2634                 while (tc && tc->prev) tc = tc->prev;
2635                 if (tc) {
2636                         tc = tc->parent;
2637                 }
2638         }
2639         fflush(file);
2640 }
2641
2642 /*
2643   return 1 if ptr is a parent of context
2644 */
2645 static int _talloc_is_parent(const void *context, const void *ptr, int depth)
2646 {
2647         struct talloc_chunk *tc;
2648
2649         if (context == NULL) {
2650                 return 0;
2651         }
2652
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;
2657                 if (tc) {
2658                         tc = tc->parent;
2659                         depth--;
2660                 }
2661         }
2662         return 0;
2663 }
2664
2665 /*
2666   return 1 if ptr is a parent of context
2667 */
2668 _PUBLIC_ int talloc_is_parent(const void *context, const void *ptr)
2669 {
2670         return _talloc_is_parent(context, ptr, TALLOC_MAX_DEPTH);
2671 }
2672
2673 /*
2674   return the total size of memory used by this context and all children
2675 */
2676 static inline size_t _talloc_total_limit_size(const void *ptr,
2677                                         struct talloc_memlimit *old_limit,
2678                                         struct talloc_memlimit *new_limit)
2679 {
2680         return _talloc_total_mem_internal(ptr, TOTAL_MEM_LIMIT,
2681                                           old_limit, new_limit);
2682 }
2683
2684 static inline bool talloc_memlimit_check(struct talloc_memlimit *limit, size_t size)
2685 {
2686         struct talloc_memlimit *l;
2687
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))) {
2692                         return false;
2693                 }
2694         }
2695
2696         return true;
2697 }
2698
2699 /*
2700   Update memory limits when freeing a talloc_chunk.
2701 */
2702 static void talloc_memlimit_update_on_free(struct talloc_chunk *tc)
2703 {
2704         size_t limit_shrink_size;
2705
2706         if (!tc->limit) {
2707                 return;
2708         }
2709
2710         /*
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.
2716          */
2717         if (tc->flags & TALLOC_FLAG_POOLMEM) {
2718                 return;
2719         }
2720
2721         /*
2722          * If we are part of a memory limited context hierarchy
2723          * we need to subtract the memory used from the counters
2724          */
2725
2726         limit_shrink_size = tc->size+TC_HDR_SIZE;
2727
2728         /*
2729          * If we're deallocating a pool, take into
2730          * account the prefix size added for the pool.
2731          */
2732
2733         if (tc->flags & TALLOC_FLAG_POOL) {
2734                 limit_shrink_size += TP_HDR_SIZE;
2735         }
2736
2737         talloc_memlimit_shrink(tc->limit, limit_shrink_size);
2738
2739         if (tc->limit->parent == tc) {
2740                 free(tc->limit);
2741         }
2742
2743         tc->limit = NULL;
2744 }
2745
2746 /*
2747   Increase memory limit accounting after a malloc/realloc.
2748 */
2749 static void talloc_memlimit_grow(struct talloc_memlimit *limit,
2750                                 size_t size)
2751 {
2752         struct talloc_memlimit *l;
2753
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");
2758                         return;
2759                 }
2760                 l->cur_size = new_cur_size;
2761         }
2762 }
2763
2764 /*
2765   Decrease memory limit accounting after a free/realloc.
2766 */
2767 static void talloc_memlimit_shrink(struct talloc_memlimit *limit,
2768                                 size_t size)
2769 {
2770         struct talloc_memlimit *l;
2771
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");
2775                         return;
2776                 }
2777                 l->cur_size = l->cur_size - size;
2778         }
2779 }
2780
2781 _PUBLIC_ int talloc_set_memlimit(const void *ctx, size_t max_size)
2782 {
2783         struct talloc_chunk *tc = talloc_chunk_from_ptr(ctx);
2784         struct talloc_memlimit *orig_limit;
2785         struct talloc_memlimit *limit = NULL;
2786
2787         if (tc->limit && tc->limit->parent == tc) {
2788                 tc->limit->max_size = max_size;
2789                 return 0;
2790         }
2791         orig_limit = tc->limit;
2792
2793         limit = malloc(sizeof(struct talloc_memlimit));
2794         if (limit == NULL) {
2795                 return 1;
2796         }
2797         limit->parent = tc;
2798         limit->max_size = max_size;
2799         limit->cur_size = _talloc_total_limit_size(ctx, tc->limit, limit);
2800
2801         if (orig_limit) {
2802                 limit->upper = orig_limit;
2803         } else {
2804                 limit->upper = NULL;
2805         }
2806
2807         return 0;
2808 }