git.ozlabs.org Git - ccan/blob - 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 2 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, write to the Free Software
  27    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  28 */
  29
  30 /*
  31   inspired by http://swapped.cc/halloc/
  32 */
  33
  34 #include "talloc.h"
  35 #include <string.h>
  36 #include <stdint.h>
  37
  38 /* use this to force every realloc to change the pointer, to stress test
  39    code that might not cope */
  40 #define ALWAYS_REALLOC 0
  41
  42
  43 #define MAX_TALLOC_SIZE 0x10000000
  44 #define TALLOC_MAGIC 0xe814ec70
  45 #define TALLOC_FLAG_FREE 0x01
  46 #define TALLOC_FLAG_LOOP 0x02
  47 #define TALLOC_MAGIC_REFERENCE ((const char *)1)
  48
  49 /* by default we abort when given a bad pointer (such as when talloc_free() is called
  50    on a pointer that came from malloc() */
  51 #ifndef TALLOC_ABORT
  52 #define TALLOC_ABORT(reason) abort()
  53 #endif
  54
  55 #ifndef discard_const_p
  56 #if defined(INTPTR_MIN)
  57 # define discard_const_p(type, ptr) ((type *)((intptr_t)(ptr)))
  58 #else
  59 # define discard_const_p(type, ptr) ((type *)(ptr))
  60 #endif
  61 #endif
  62
  63 /* these macros gain us a few percent of speed on gcc */
  64 #if HAVE_BUILTIN_EXPECT
  65 /* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
  66    as its first argument */
  67 #define likely(x)   __builtin_expect(!!(x), 1)
  68 #define unlikely(x) __builtin_expect(!!(x), 0)
  69 #else
  70 #define likely(x) x
  71 #define unlikely(x) x
  72 #endif
  73
  74 /* this null_context is only used if talloc_enable_leak_report() or
  75    talloc_enable_leak_report_full() is called, otherwise it remains
  76    NULL
  77 */
  78 static void *null_context;
  79 static void *autofree_context;
  80
  81 struct talloc_reference_handle {
  82         struct talloc_reference_handle *next, *prev;
  83         void *ptr;
  84 };
  85
  86 typedef int (*talloc_destructor_t)(void *);
  87
  88 struct talloc_chunk {
  89         struct talloc_chunk *next, *prev;
  90         struct talloc_chunk *parent, *child;
  91         struct talloc_reference_handle *refs;
  92         talloc_destructor_t destructor;
  93         const char *name;
  94         size_t size;
  95         unsigned flags;
  96 };
  97
  98 /* 16 byte alignment seems to keep everyone happy */
  99 #define TC_HDR_SIZE ((sizeof(struct talloc_chunk)+15)&~15)
 100 #define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
 101
 102 /* panic if we get a bad magic value */
 103 static inline struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
 104 {
 105         const char *pp = (const char *)ptr;
 106         struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp - TC_HDR_SIZE);
 107         if (unlikely((tc->flags & (TALLOC_FLAG_FREE | ~0xF)) != TALLOC_MAGIC)) {
 108                 if (tc->flags & TALLOC_FLAG_FREE) {
 109                         TALLOC_ABORT("Bad talloc magic value - double free");
 110                 } else {
 111                         TALLOC_ABORT("Bad talloc magic value - unknown value");
 112                 }
 113         }
 114         return tc;
 115 }
 116
 117 /* hook into the front of the list */
 118 #define _TLIST_ADD(list, p) \
 119 do { \
 120         if (!(list)) { \
 121                 (list) = (p); \
 122                 (p)->next = (p)->prev = NULL; \
 123         } else { \
 124                 (list)->prev = (p); \
 125                 (p)->next = (list); \
 126                 (p)->prev = NULL; \
 127                 (list) = (p); \
 128         }\
 129 } while (0)
 130
 131 /* remove an element from a list - element doesn't have to be in list. */
 132 #define _TLIST_REMOVE(list, p) \
 133 do { \
 134         if ((p) == (list)) { \
 135                 (list) = (p)->next; \
 136                 if (list) (list)->prev = NULL; \
 137         } else { \
 138                 if ((p)->prev) (p)->prev->next = (p)->next; \
 139                 if ((p)->next) (p)->next->prev = (p)->prev; \
 140         } \
 141         if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \
 142 } while (0)
 143
 144
 145 /*
 146   return the parent chunk of a pointer
 147 */
 148 static inline struct talloc_chunk *talloc_parent_chunk(const void *ptr)
 149 {
 150         struct talloc_chunk *tc;
 151
 152         if (unlikely(ptr == NULL)) {
 153                 return NULL;
 154         }
 155
 156         tc = talloc_chunk_from_ptr(ptr);
 157         while (tc->prev) tc=tc->prev;
 158
 159         return tc->parent;
 160 }
 161
 162 void *talloc_parent(const void *ptr)
 163 {
 164         struct talloc_chunk *tc = talloc_parent_chunk(ptr);
 165         return tc? TC_PTR_FROM_CHUNK(tc) : NULL;
 166 }
 167
 168 /*
 169   find parents name
 170 */
 171 const char *talloc_parent_name(const void *ptr)
 172 {
 173         struct talloc_chunk *tc = talloc_parent_chunk(ptr);
 174         return tc? tc->name : NULL;
 175 }
 176
 177 /*
 178    Allocate a bit of memory as a child of an existing pointer
 179 */
 180 static inline void *__talloc(const void *context, size_t size)
 181 {
 182         struct talloc_chunk *tc;
 183
 184         if (unlikely(context == NULL)) {
 185                 context = null_context;
 186         }
 187
 188         if (unlikely(size >= MAX_TALLOC_SIZE)) {
 189                 return NULL;
 190         }
 191
 192         tc = (struct talloc_chunk *)malloc(TC_HDR_SIZE+size);
 193         if (unlikely(tc == NULL)) return NULL;
 194
 195         tc->size = size;
 196         tc->flags = TALLOC_MAGIC;
 197         tc->destructor = NULL;
 198         tc->child = NULL;
 199         tc->name = NULL;
 200         tc->refs = NULL;
 201
 202         if (likely(context)) {
 203                 struct talloc_chunk *parent = talloc_chunk_from_ptr(context);
 204
 205                 if (parent->child) {
 206                         parent->child->parent = NULL;
 207                         tc->next = parent->child;
 208                         tc->next->prev = tc;
 209                 } else {
 210                         tc->next = NULL;
 211                 }
 212                 tc->parent = parent;
 213                 tc->prev = NULL;
 214                 parent->child = tc;
 215         } else {
 216                 tc->next = tc->prev = tc->parent = NULL;
 217         }
 218
 219         return TC_PTR_FROM_CHUNK(tc);
 220 }
 221
 222 /*
 223   setup a destructor to be called on free of a pointer
 224   the destructor should return 0 on success, or -1 on failure.
 225   if the destructor fails then the free is failed, and the memory can
 226   be continued to be used
 227 */
 228 void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
 229 {
 230         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 231         tc->destructor = destructor;
 232 }
 233
 234 /*
 235   increase the reference count on a piece of memory.
 236 */
 237 int talloc_increase_ref_count(const void *ptr)
 238 {
 239         if (unlikely(!talloc_reference(null_context, ptr))) {
 240                 return -1;
 241         }
 242         return 0;
 243 }
 244
 245 /*
 246   helper for talloc_reference()
 247
 248   this is referenced by a function pointer and should not be inline
 249 */
 250 static int talloc_reference_destructor(struct talloc_reference_handle *handle)
 251 {
 252         struct talloc_chunk *ptr_tc = talloc_chunk_from_ptr(handle->ptr);
 253         _TLIST_REMOVE(ptr_tc->refs, handle);
 254         return 0;
 255 }
 256
 257 /*
 258    more efficient way to add a name to a pointer - the name must point to a
 259    true string constant
 260 */
 261 static inline void _talloc_set_name_const(const void *ptr, const char *name)
 262 {
 263         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 264         tc->name = name;
 265 }
 266
 267 /*
 268   internal talloc_named_const()
 269 */
 270 static inline void *_talloc_named_const(const void *context, size_t size, const char *name)
 271 {
 272         void *ptr;
 273
 274         ptr = __talloc(context, size);
 275         if (unlikely(ptr == NULL)) {
 276                 return NULL;
 277         }
 278
 279         _talloc_set_name_const(ptr, name);
 280
 281         return ptr;
 282 }
 283
 284 /*
 285   make a secondary reference to a pointer, hanging off the given context.
 286   the pointer remains valid until both the original caller and this given
 287   context are freed.
 288
 289   the major use for this is when two different structures need to reference the
 290   same underlying data, and you want to be able to free the two instances separately,
 291   and in either order
 292 */
 293 void *_talloc_reference(const void *context, const void *ptr)
 294 {
 295         struct talloc_chunk *tc;
 296         struct talloc_reference_handle *handle;
 297         if (unlikely(ptr == NULL)) return NULL;
 298
 299         tc = talloc_chunk_from_ptr(ptr);
 300         handle = (struct talloc_reference_handle *)_talloc_named_const(context,
 301                                                    sizeof(struct talloc_reference_handle),
 302                                                    TALLOC_MAGIC_REFERENCE);
 303         if (unlikely(handle == NULL)) return NULL;
 304
 305         /* note that we hang the destructor off the handle, not the
 306            main context as that allows the caller to still setup their
 307            own destructor on the context if they want to */
 308         talloc_set_destructor(handle, talloc_reference_destructor);
 309         handle->ptr = discard_const_p(void, ptr);
 310         _TLIST_ADD(tc->refs, handle);
 311         return handle->ptr;
 312 }
 313
 314
 315 /*
 316    internal talloc_free call
 317 */
 318 static inline int _talloc_free(void *ptr)
 319 {
 320         struct talloc_chunk *tc;
 321
 322         if (unlikely(ptr == NULL)) {
 323                 return -1;
 324         }
 325
 326         tc = talloc_chunk_from_ptr(ptr);
 327
 328         if (unlikely(tc->refs)) {
 329                 int is_child;
 330                 /* check this is a reference from a child or grantchild
 331                  * back to it's parent or grantparent
 332                  *
 333                  * in that case we need to remove the reference and
 334                  * call another instance of talloc_free() on the current
 335                  * pointer.
 336                  */
 337                 is_child = talloc_is_parent(tc->refs, ptr);
 338                 _talloc_free(tc->refs);
 339                 if (is_child) {
 340                         return _talloc_free(ptr);
 341                 }
 342                 return -1;
 343         }
 344
 345         if (unlikely(tc->flags & TALLOC_FLAG_LOOP)) {
 346                 /* we have a free loop - stop looping */
 347                 return 0;
 348         }
 349
 350         if (unlikely(tc->destructor)) {
 351                 talloc_destructor_t d = tc->destructor;
 352                 if (d == (talloc_destructor_t)-1) {
 353                         return -1;
 354                 }
 355                 tc->destructor = (talloc_destructor_t)-1;
 356                 if (d(ptr) == -1) {
 357                         tc->destructor = d;
 358                         return -1;
 359                 }
 360                 tc->destructor = NULL;
 361         }
 362
 363         if (tc->parent) {
 364                 _TLIST_REMOVE(tc->parent->child, tc);
 365                 if (tc->parent->child) {
 366                         tc->parent->child->parent = tc->parent;
 367                 }
 368         } else {
 369                 if (tc->prev) tc->prev->next = tc->next;
 370                 if (tc->next) tc->next->prev = tc->prev;
 371         }
 372
 373         tc->flags |= TALLOC_FLAG_LOOP;
 374
 375         while (tc->child) {
 376                 /* we need to work out who will own an abandoned child
 377                    if it cannot be freed. In priority order, the first
 378                    choice is owner of any remaining reference to this
 379                    pointer, the second choice is our parent, and the
 380                    final choice is the null context. */
 381                 void *child = TC_PTR_FROM_CHUNK(tc->child);
 382                 const void *new_parent = null_context;
 383                 if (unlikely(tc->child->refs)) {
 384                         struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
 385                         if (p) new_parent = TC_PTR_FROM_CHUNK(p);
 386                 }
 387                 if (unlikely(_talloc_free(child) == -1)) {
 388                         if (new_parent == null_context) {
 389                                 struct talloc_chunk *p = talloc_parent_chunk(ptr);
 390                                 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
 391                         }
 392                         talloc_steal(new_parent, child);
 393                 }
 394         }
 395
 396         tc->flags |= TALLOC_FLAG_FREE;
 397         free(tc);
 398         return 0;
 399 }
 400
 401 /*
 402    move a lump of memory from one talloc context to another return the
 403    ptr on success, or NULL if it could not be transferred.
 404    passing NULL as ptr will always return NULL with no side effects.
 405 */
 406 void *_talloc_steal(const void *new_ctx, const void *ptr)
 407 {
 408         struct talloc_chunk *tc, *new_tc;
 409
 410         if (unlikely(!ptr)) {
 411                 return NULL;
 412         }
 413
 414         if (unlikely(new_ctx == NULL)) {
 415                 new_ctx = null_context;
 416         }
 417
 418         tc = talloc_chunk_from_ptr(ptr);
 419
 420         if (unlikely(new_ctx == NULL)) {
 421                 if (tc->parent) {
 422                         _TLIST_REMOVE(tc->parent->child, tc);
 423                         if (tc->parent->child) {
 424                                 tc->parent->child->parent = tc->parent;
 425                         }
 426                 } else {
 427                         if (tc->prev) tc->prev->next = tc->next;
 428                         if (tc->next) tc->next->prev = tc->prev;
 429                 }
 430
 431                 tc->parent = tc->next = tc->prev = NULL;
 432                 return discard_const_p(void, ptr);
 433         }
 434
 435         new_tc = talloc_chunk_from_ptr(new_ctx);
 436
 437         if (unlikely(tc == new_tc || tc->parent == new_tc)) {
 438                 return discard_const_p(void, ptr);
 439         }
 440
 441         if (tc->parent) {
 442                 _TLIST_REMOVE(tc->parent->child, tc);
 443                 if (tc->parent->child) {
 444                         tc->parent->child->parent = tc->parent;
 445                 }
 446         } else {
 447                 if (tc->prev) tc->prev->next = tc->next;
 448                 if (tc->next) tc->next->prev = tc->prev;
 449         }
 450
 451         tc->parent = new_tc;
 452         if (new_tc->child) new_tc->child->parent = NULL;
 453         _TLIST_ADD(new_tc->child, tc);
 454
 455         return discard_const_p(void, ptr);
 456 }
 457
 458
 459
 460 /*
 461   remove a secondary reference to a pointer. This undo's what
 462   talloc_reference() has done. The context and pointer arguments
 463   must match those given to a talloc_reference()
 464 */
 465 static inline int talloc_unreference(const void *context, const void *ptr)
 466 {
 467         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 468         struct talloc_reference_handle *h;
 469
 470         if (unlikely(context == NULL)) {
 471                 context = null_context;
 472         }
 473
 474         for (h=tc->refs;h;h=h->next) {
 475                 struct talloc_chunk *p = talloc_parent_chunk(h);
 476                 if (p == NULL) {
 477                         if (context == NULL) break;
 478                 } else if (TC_PTR_FROM_CHUNK(p) == context) {
 479                         break;
 480                 }
 481         }
 482         if (h == NULL) {
 483                 return -1;
 484         }
 485
 486         return _talloc_free(h);
 487 }
 488
 489 /*
 490   remove a specific parent context from a pointer. This is a more
 491   controlled varient of talloc_free()
 492 */
 493 int talloc_unlink(const void *context, void *ptr)
 494 {
 495         struct talloc_chunk *tc_p, *new_p;
 496         void *new_parent;
 497
 498         if (ptr == NULL) {
 499                 return -1;
 500         }
 501
 502         if (context == NULL) {
 503                 context = null_context;
 504         }
 505
 506         if (talloc_unreference(context, ptr) == 0) {
 507                 return 0;
 508         }
 509
 510         if (context == NULL) {
 511                 if (talloc_parent_chunk(ptr) != NULL) {
 512                         return -1;
 513                 }
 514         } else {
 515                 if (talloc_chunk_from_ptr(context) != talloc_parent_chunk(ptr)) {
 516                         return -1;
 517                 }
 518         }
 519
 520         tc_p = talloc_chunk_from_ptr(ptr);
 521
 522         if (tc_p->refs == NULL) {
 523                 return _talloc_free(ptr);
 524         }
 525
 526         new_p = talloc_parent_chunk(tc_p->refs);
 527         if (new_p) {
 528                 new_parent = TC_PTR_FROM_CHUNK(new_p);
 529         } else {
 530                 new_parent = NULL;
 531         }
 532
 533         if (talloc_unreference(new_parent, ptr) != 0) {
 534                 return -1;
 535         }
 536
 537         talloc_steal(new_parent, ptr);
 538
 539         return 0;
 540 }
 541
 542 /*
 543   add a name to an existing pointer - va_list version
 544 */
 545 static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
 546
 547 static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
 548 {
 549         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 550         tc->name = talloc_vasprintf(ptr, fmt, ap);
 551         if (likely(tc->name)) {
 552                 _talloc_set_name_const(tc->name, ".name");
 553         }
 554         return tc->name;
 555 }
 556
 557 /*
 558   add a name to an existing pointer
 559 */
 560 const char *talloc_set_name(const void *ptr, const char *fmt, ...)
 561 {
 562         const char *name;
 563         va_list ap;
 564         va_start(ap, fmt);
 565         name = talloc_set_name_v(ptr, fmt, ap);
 566         va_end(ap);
 567         return name;
 568 }
 569
 570
 571 /*
 572   create a named talloc pointer. Any talloc pointer can be named, and
 573   talloc_named() operates just like talloc() except that it allows you
 574   to name the pointer.
 575 */
 576 void *talloc_named(const void *context, size_t size, const char *fmt, ...)
 577 {
 578         va_list ap;
 579         void *ptr;
 580         const char *name;
 581
 582         ptr = __talloc(context, size);
 583         if (unlikely(ptr == NULL)) return NULL;
 584
 585         va_start(ap, fmt);
 586         name = talloc_set_name_v(ptr, fmt, ap);
 587         va_end(ap);
 588
 589         if (unlikely(name == NULL)) {
 590                 _talloc_free(ptr);
 591                 return NULL;
 592         }
 593
 594         return ptr;
 595 }
 596
 597 /*
 598   return the name of a talloc ptr, or "UNNAMED"
 599 */
 600 const char *talloc_get_name(const void *ptr)
 601 {
 602         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 603         if (unlikely(tc->name == TALLOC_MAGIC_REFERENCE)) {
 604                 return ".reference";
 605         }
 606         if (likely(tc->name)) {
 607                 return tc->name;
 608         }
 609         return "UNNAMED";
 610 }
 611
 612
 613 /*
 614   check if a pointer has the given name. If it does, return the pointer,
 615   otherwise return NULL
 616 */
 617 void *talloc_check_name(const void *ptr, const char *name)
 618 {
 619         const char *pname;
 620         if (unlikely(ptr == NULL)) return NULL;
 621         pname = talloc_get_name(ptr);
 622         if (likely(pname == name || strcmp(pname, name) == 0)) {
 623                 return discard_const_p(void, ptr);
 624         }
 625         return NULL;
 626 }
 627
 628
 629 /*
 630   this is for compatibility with older versions of talloc
 631 */
 632 void *talloc_init(const char *fmt, ...)
 633 {
 634         va_list ap;
 635         void *ptr;
 636         const char *name;
 637
 638         /*
 639          * samba3 expects talloc_report_depth_cb(NULL, ...)
 640          * reports all talloc'ed memory, so we need to enable
 641          * null_tracking
 642          */
 643         talloc_enable_null_tracking();
 644
 645         ptr = __talloc(NULL, 0);
 646         if (unlikely(ptr == NULL)) return NULL;
 647
 648         va_start(ap, fmt);
 649         name = talloc_set_name_v(ptr, fmt, ap);
 650         va_end(ap);
 651
 652         if (unlikely(name == NULL)) {
 653                 _talloc_free(ptr);
 654                 return NULL;
 655         }
 656
 657         return ptr;
 658 }
 659
 660 /*
 661   this is a replacement for the Samba3 talloc_destroy_pool functionality. It
 662   should probably not be used in new code. It's in here to keep the talloc
 663   code consistent across Samba 3 and 4.
 664 */
 665 void talloc_free_children(void *ptr)
 666 {
 667         struct talloc_chunk *tc;
 668
 669         if (unlikely(ptr == NULL)) {
 670                 return;
 671         }
 672
 673         tc = talloc_chunk_from_ptr(ptr);
 674
 675         while (tc->child) {
 676                 /* we need to work out who will own an abandoned child
 677                    if it cannot be freed. In priority order, the first
 678                    choice is owner of any remaining reference to this
 679                    pointer, the second choice is our parent, and the
 680                    final choice is the null context. */
 681                 void *child = TC_PTR_FROM_CHUNK(tc->child);
 682                 const void *new_parent = null_context;
 683                 if (unlikely(tc->child->refs)) {
 684                         struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
 685                         if (p) new_parent = TC_PTR_FROM_CHUNK(p);
 686                 }
 687                 if (unlikely(_talloc_free(child) == -1)) {
 688                         if (new_parent == null_context) {
 689                                 struct talloc_chunk *p = talloc_parent_chunk(ptr);
 690                                 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
 691                         }
 692                         talloc_steal(new_parent, child);
 693                 }
 694         }
 695 }
 696
 697 /*
 698    Allocate a bit of memory as a child of an existing pointer
 699 */
 700 void *_talloc(const void *context, size_t size)
 701 {
 702         return __talloc(context, size);
 703 }
 704
 705 /*
 706   externally callable talloc_set_name_const()
 707 */
 708 void talloc_set_name_const(const void *ptr, const char *name)
 709 {
 710         _talloc_set_name_const(ptr, name);
 711 }
 712
 713 /*
 714   create a named talloc pointer. Any talloc pointer can be named, and
 715   talloc_named() operates just like talloc() except that it allows you
 716   to name the pointer.
 717 */
 718 void *talloc_named_const(const void *context, size_t size, const char *name)
 719 {
 720         return _talloc_named_const(context, size, name);
 721 }
 722
 723 /*
 724    free a talloc pointer. This also frees all child pointers of this
 725    pointer recursively
 726
 727    return 0 if the memory is actually freed, otherwise -1. The memory
 728    will not be freed if the ref_count is > 1 or the destructor (if
 729    any) returns non-zero
 730 */
 731 int talloc_free(void *ptr)
 732 {
 733         int saved_errno = errno, ret;
 734         ret = _talloc_free(ptr);
 735         if (ret == 0)
 736                 errno = saved_errno;
 737         return ret;
 738 }
 739
 740
 741
 742 /*
 743   A talloc version of realloc. The context argument is only used if
 744   ptr is NULL
 745 */
 746 void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name)
 747 {
 748         struct talloc_chunk *tc;
 749         void *new_ptr;
 750
 751         /* size zero is equivalent to free() */
 752         if (unlikely(size == 0)) {
 753                 _talloc_free(ptr);
 754                 return NULL;
 755         }
 756
 757         if (unlikely(size >= MAX_TALLOC_SIZE)) {
 758                 return NULL;
 759         }
 760
 761         /* realloc(NULL) is equivalent to malloc() */
 762         if (ptr == NULL) {
 763                 return _talloc_named_const(context, size, name);
 764         }
 765
 766         tc = talloc_chunk_from_ptr(ptr);
 767
 768         /* don't allow realloc on referenced pointers */
 769         if (unlikely(tc->refs)) {
 770                 return NULL;
 771         }
 772
 773         /* by resetting magic we catch users of the old memory */
 774         tc->flags |= TALLOC_FLAG_FREE;
 775
 776 #if ALWAYS_REALLOC
 777         new_ptr = malloc(size + TC_HDR_SIZE);
 778         if (new_ptr) {
 779                 memcpy(new_ptr, tc, tc->size + TC_HDR_SIZE);
 780                 free(tc);
 781         }
 782 #else
 783         new_ptr = realloc(tc, size + TC_HDR_SIZE);
 784 #endif
 785         if (unlikely(!new_ptr)) {
 786                 tc->flags &= ~TALLOC_FLAG_FREE;
 787                 return NULL;
 788         }
 789
 790         tc = (struct talloc_chunk *)new_ptr;
 791         tc->flags &= ~TALLOC_FLAG_FREE;
 792         if (tc->parent) {
 793                 tc->parent->child = tc;
 794         }
 795         if (tc->child) {
 796                 tc->child->parent = tc;
 797         }
 798
 799         if (tc->prev) {
 800                 tc->prev->next = tc;
 801         }
 802         if (tc->next) {
 803                 tc->next->prev = tc;
 804         }
 805
 806         tc->size = size;
 807         _talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
 808
 809         return TC_PTR_FROM_CHUNK(tc);
 810 }
 811
 812 /*
 813   a wrapper around talloc_steal() for situations where you are moving a pointer
 814   between two structures, and want the old pointer to be set to NULL
 815 */
 816 void *_talloc_move(const void *new_ctx, const void *_pptr)
 817 {
 818         const void **pptr = discard_const_p(const void *,_pptr);
 819         void *ret = _talloc_steal(new_ctx, *pptr);
 820         (*pptr) = NULL;
 821         return ret;
 822 }
 823
 824 /*
 825   return the total size of a talloc pool (subtree)
 826 */
 827 size_t talloc_total_size(const void *ptr)
 828 {
 829         size_t total = 0;
 830         struct talloc_chunk *c, *tc;
 831
 832         if (ptr == NULL) {
 833                 ptr = null_context;
 834         }
 835         if (ptr == NULL) {
 836                 return 0;
 837         }
 838
 839         tc = talloc_chunk_from_ptr(ptr);
 840
 841         if (tc->flags & TALLOC_FLAG_LOOP) {
 842                 return 0;
 843         }
 844
 845         tc->flags |= TALLOC_FLAG_LOOP;
 846
 847         total = tc->size;
 848         for (c=tc->child;c;c=c->next) {
 849                 total += talloc_total_size(TC_PTR_FROM_CHUNK(c));
 850         }
 851
 852         tc->flags &= ~TALLOC_FLAG_LOOP;
 853
 854         return total;
 855 }
 856
 857 /*
 858   return the total number of blocks in a talloc pool (subtree)
 859 */
 860 size_t talloc_total_blocks(const void *ptr)
 861 {
 862         size_t total = 0;
 863         struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
 864
 865         if (tc->flags & TALLOC_FLAG_LOOP) {
 866                 return 0;
 867         }
 868
 869         tc->flags |= TALLOC_FLAG_LOOP;
 870
 871         total++;
 872         for (c=tc->child;c;c=c->next) {
 873                 total += talloc_total_blocks(TC_PTR_FROM_CHUNK(c));
 874         }
 875
 876         tc->flags &= ~TALLOC_FLAG_LOOP;
 877
 878         return total;
 879 }
 880
 881 /*
 882   return the number of external references to a pointer
 883 */
 884 size_t talloc_reference_count(const void *ptr)
 885 {
 886         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 887         struct talloc_reference_handle *h;
 888         size_t ret = 0;
 889
 890         for (h=tc->refs;h;h=h->next) {
 891                 ret++;
 892         }
 893         return ret;
 894 }
 895
 896 /*
 897   report on memory usage by all children of a pointer, giving a full tree view
 898 */
 899 void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
 900                             void (*callback)(const void *ptr,
 901                                              int depth, int max_depth,
 902                                              int is_ref,
 903                                              void *private_data),
 904                             void *private_data)
 905 {
 906         struct talloc_chunk *c, *tc;
 907
 908         if (ptr == NULL) {
 909                 ptr = null_context;
 910         }
 911         if (ptr == NULL) return;
 912
 913         tc = talloc_chunk_from_ptr(ptr);
 914
 915         if (tc->flags & TALLOC_FLAG_LOOP) {
 916                 return;
 917         }
 918
 919         callback(ptr, depth, max_depth, 0, private_data);
 920
 921         if (max_depth >= 0 && depth >= max_depth) {
 922                 return;
 923         }
 924
 925         tc->flags |= TALLOC_FLAG_LOOP;
 926         for (c=tc->child;c;c=c->next) {
 927                 if (c->name == TALLOC_MAGIC_REFERENCE) {
 928                         struct talloc_reference_handle *h = (struct talloc_reference_handle *)TC_PTR_FROM_CHUNK(c);
 929                         callback(h->ptr, depth + 1, max_depth, 1, private_data);
 930                 } else {
 931                         talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c), depth + 1, max_depth, callback, private_data);
 932                 }
 933         }
 934         tc->flags &= ~TALLOC_FLAG_LOOP;
 935 }
 936
 937 static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_depth, int is_ref, void *_f)
 938 {
 939         const char *name = talloc_get_name(ptr);
 940         FILE *f = (FILE *)_f;
 941
 942         if (is_ref) {
 943                 fprintf(f, "%*sreference to: %s\n", depth*4, "", name);
 944                 return;
 945         }
 946
 947         if (depth == 0) {
 948                 fprintf(f,"%stalloc report on '%s' (total %6lu bytes in %3lu blocks)\n",
 949                         (max_depth < 0 ? "full " :""), name,
 950                         (unsigned long)talloc_total_size(ptr),
 951                         (unsigned long)talloc_total_blocks(ptr));
 952                 return;
 953         }
 954
 955         fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d) %p\n",
 956                 depth*4, "",
 957                 name,
 958                 (unsigned long)talloc_total_size(ptr),
 959                 (unsigned long)talloc_total_blocks(ptr),
 960                 (int)talloc_reference_count(ptr), ptr);
 961
 962 #if 0
 963         fprintf(f, "content: ");
 964         if (talloc_total_size(ptr)) {
 965                 int tot = talloc_total_size(ptr);
 966                 int i;
 967
 968                 for (i = 0; i < tot; i++) {
 969                         if ((((char *)ptr)[i] > 31) && (((char *)ptr)[i] < 126)) {
 970                                 fprintf(f, "%c", ((char *)ptr)[i]);
 971                         } else {
 972                                 fprintf(f, "~%02x", ((char *)ptr)[i]);
 973                         }
 974                 }
 975         }
 976         fprintf(f, "\n");
 977 #endif
 978 }
 979
 980 /*
 981   report on memory usage by all children of a pointer, giving a full tree view
 982 */
 983 void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f)
 984 {
 985         talloc_report_depth_cb(ptr, depth, max_depth, talloc_report_depth_FILE_helper, f);
 986         fflush(f);
 987 }
 988
 989 /*
 990   report on memory usage by all children of a pointer, giving a full tree view
 991 */
 992 void talloc_report_full(const void *ptr, FILE *f)
 993 {
 994         talloc_report_depth_file(ptr, 0, -1, f);
 995 }
 996
 997 /*
 998   report on memory usage by all children of a pointer
 999 */
1000 void talloc_report(const void *ptr, FILE *f)
1001 {
1002         talloc_report_depth_file(ptr, 0, 1, f);
1003 }
1004
1005 /*
1006   report on any memory hanging off the null context
1007 */
1008 static void talloc_report_null(void)
1009 {
1010         if (talloc_total_size(null_context) != 0) {
1011                 talloc_report(null_context, stderr);
1012         }
1013 }
1014
1015 /*
1016   report on any memory hanging off the null context
1017 */
1018 static void talloc_report_null_full(void)
1019 {
1020         if (talloc_total_size(null_context) != 0) {
1021                 talloc_report_full(null_context, stderr);
1022         }
1023 }
1024
1025 /*
1026   enable tracking of the NULL context
1027 */
1028 void talloc_enable_null_tracking(void)
1029 {
1030         if (null_context == NULL) {
1031                 null_context = _talloc_named_const(NULL, 0, "null_context");
1032         }
1033 }
1034
1035 /*
1036   disable tracking of the NULL context
1037 */
1038 void talloc_disable_null_tracking(void)
1039 {
1040         _talloc_free(null_context);
1041         null_context = NULL;
1042 }
1043
1044 /*
1045   enable leak reporting on exit
1046 */
1047 void talloc_enable_leak_report(void)
1048 {
1049         talloc_enable_null_tracking();
1050         atexit(talloc_report_null);
1051 }
1052
1053 /*
1054   enable full leak reporting on exit
1055 */
1056 void talloc_enable_leak_report_full(void)
1057 {
1058         talloc_enable_null_tracking();
1059         atexit(talloc_report_null_full);
1060 }
1061
1062 /*
1063    talloc and zero memory.
1064 */
1065 void *_talloc_zero(const void *ctx, size_t size, const char *name)
1066 {
1067         void *p = _talloc_named_const(ctx, size, name);
1068
1069         if (p) {
1070                 memset(p, '\0', size);
1071         }
1072
1073         return p;
1074 }
1075
1076 /*
1077   memdup with a talloc.
1078 */
1079 void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
1080 {
1081         void *newp = _talloc_named_const(t, size, name);
1082
1083         if (likely(newp)) {
1084                 memcpy(newp, p, size);
1085         }
1086
1087         return newp;
1088 }
1089
1090 /*
1091   strdup with a talloc
1092 */
1093 char *talloc_strdup(const void *t, const char *p)
1094 {
1095         char *ret;
1096         if (!p) {
1097                 return NULL;
1098         }
1099         ret = (char *)talloc_memdup(t, p, strlen(p) + 1);
1100         if (likely(ret)) {
1101                 _talloc_set_name_const(ret, ret);
1102         }
1103         return ret;
1104 }
1105
1106 /*
1107  append to a talloced string
1108 */
1109 char *talloc_append_string(char *orig, const char *append)
1110 {
1111         char *ret;
1112         size_t olen = strlen(orig);
1113         size_t alenz;
1114
1115         if (!append)
1116                 return orig;
1117
1118         alenz = strlen(append) + 1;
1119
1120         ret = talloc_realloc(NULL, orig, char, olen + alenz);
1121         if (!ret)
1122                 return NULL;
1123
1124         /* append the string with the trailing \0 */
1125         memcpy(&ret[olen], append, alenz);
1126
1127         _talloc_set_name_const(ret, ret);
1128
1129         return ret;
1130 }
1131
1132 /*
1133   strndup with a talloc
1134 */
1135 char *talloc_strndup(const void *t, const char *p, size_t n)
1136 {
1137         size_t len;
1138         char *ret;
1139
1140         for (len=0; len<n && p[len]; len++) ;
1141
1142         ret = (char *)__talloc(t, len + 1);
1143         if (!ret) { return NULL; }
1144         memcpy(ret, p, len);
1145         ret[len] = 0;
1146         _talloc_set_name_const(ret, ret);
1147         return ret;
1148 }
1149
1150 char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
1151 {
1152         int len;
1153         char *ret;
1154         va_list ap2;
1155         char c;
1156
1157         /* this call looks strange, but it makes it work on older solaris boxes */
1158         va_copy(ap2, ap);
1159         len = vsnprintf(&c, 1, fmt, ap2);
1160         va_end(ap2);
1161         if (len < 0) {
1162                 return NULL;
1163         }
1164
1165         ret = (char *)__talloc(t, len+1);
1166         if (ret) {
1167                 va_copy(ap2, ap);
1168                 vsnprintf(ret, len+1, fmt, ap2);
1169                 va_end(ap2);
1170                 _talloc_set_name_const(ret, ret);
1171         }
1172
1173         return ret;
1174 }
1175
1176
1177 /*
1178   Perform string formatting, and return a pointer to newly allocated
1179   memory holding the result, inside a memory pool.
1180  */
1181 char *talloc_asprintf(const void *t, const char *fmt, ...)
1182 {
1183         va_list ap;
1184         char *ret;
1185
1186         va_start(ap, fmt);
1187         ret = talloc_vasprintf(t, fmt, ap);
1188         va_end(ap);
1189         return ret;
1190 }
1191
1192
1193 /**
1194  * Realloc @p s to append the formatted result of @p fmt and @p ap,
1195  * and return @p s, which may have moved.  Good for gradually
1196  * accumulating output into a string buffer.
1197  **/
1198 char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
1199 {
1200         struct talloc_chunk *tc;
1201         int len, s_len;
1202         va_list ap2;
1203         char c;
1204
1205         if (s == NULL) {
1206                 return talloc_vasprintf(NULL, fmt, ap);
1207         }
1208
1209         tc = talloc_chunk_from_ptr(s);
1210
1211         s_len = tc->size - 1;
1212
1213         va_copy(ap2, ap);
1214         len = vsnprintf(&c, 1, fmt, ap2);
1215         va_end(ap2);
1216
1217         if (len <= 0) {
1218                 /* Either the vsnprintf failed or the format resulted in
1219                  * no characters being formatted. In the former case, we
1220                  * ought to return NULL, in the latter we ought to return
1221                  * the original string. Most current callers of this
1222                  * function expect it to never return NULL.
1223                  */
1224                 return s;
1225         }
1226
1227         s = talloc_realloc(NULL, s, char, s_len + len+1);
1228         if (!s) return NULL;
1229
1230         va_copy(ap2, ap);
1231         vsnprintf(s+s_len, len+1, fmt, ap2);
1232         va_end(ap2);
1233         _talloc_set_name_const(s, s);
1234
1235         return s;
1236 }
1237
1238 /*
1239   Realloc @p s to append the formatted result of @p fmt and return @p
1240   s, which may have moved.  Good for gradually accumulating output
1241   into a string buffer.
1242  */
1243 char *talloc_asprintf_append(char *s, const char *fmt, ...)
1244 {
1245         va_list ap;
1246
1247         va_start(ap, fmt);
1248         s = talloc_vasprintf_append(s, fmt, ap);
1249         va_end(ap);
1250         return s;
1251 }
1252
1253 /*
1254   alloc an array, checking for integer overflow in the array size
1255 */
1256 void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
1257 {
1258         if (count >= MAX_TALLOC_SIZE/el_size) {
1259                 return NULL;
1260         }
1261         return _talloc_named_const(ctx, el_size * count, name);
1262 }
1263
1264 /*
1265   alloc an zero array, checking for integer overflow in the array size
1266 */
1267 void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
1268 {
1269         if (count >= MAX_TALLOC_SIZE/el_size) {
1270                 return NULL;
1271         }
1272         return _talloc_zero(ctx, el_size * count, name);
1273 }
1274
1275 /*
1276   realloc an array, checking for integer overflow in the array size
1277 */
1278 void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
1279 {
1280         if (count >= MAX_TALLOC_SIZE/el_size) {
1281                 return NULL;
1282         }
1283         return _talloc_realloc(ctx, ptr, el_size * count, name);
1284 }
1285
1286 /*
1287   a function version of talloc_realloc(), so it can be passed as a function pointer
1288   to libraries that want a realloc function (a realloc function encapsulates
1289   all the basic capabilities of an allocation library, which is why this is useful)
1290 */
1291 void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
1292 {
1293         return _talloc_realloc(context, ptr, size, NULL);
1294 }
1295
1296
1297 static int talloc_autofree_destructor(void *ptr)
1298 {
1299         autofree_context = NULL;
1300         return 0;
1301 }
1302
1303 static void talloc_autofree(void)
1304 {
1305         _talloc_free(autofree_context);
1306 }
1307
1308 /*
1309   return a context which will be auto-freed on exit
1310   this is useful for reducing the noise in leak reports
1311 */
1312 void *talloc_autofree_context(void)
1313 {
1314         if (autofree_context == NULL) {
1315                 autofree_context = _talloc_named_const(NULL, 0, "autofree_context");
1316                 talloc_set_destructor(autofree_context, talloc_autofree_destructor);
1317                 atexit(talloc_autofree);
1318         }
1319         return autofree_context;
1320 }
1321
1322 size_t talloc_get_size(const void *context)
1323 {
1324         struct talloc_chunk *tc;
1325
1326         if (context == NULL)
1327                 return 0;
1328
1329         tc = talloc_chunk_from_ptr(context);
1330
1331         return tc->size;
1332 }
1333
1334 /*
1335   find a parent of this context that has the given name, if any
1336 */
1337 void *talloc_find_parent_byname(const void *context, const char *name)
1338 {
1339         struct talloc_chunk *tc;
1340
1341         if (context == NULL) {
1342                 return NULL;
1343         }
1344
1345         tc = talloc_chunk_from_ptr(context);
1346         while (tc) {
1347                 if (tc->name && strcmp(tc->name, name) == 0) {
1348                         return TC_PTR_FROM_CHUNK(tc);
1349                 }
1350                 while (tc && tc->prev) tc = tc->prev;
1351                 if (tc) {
1352                         tc = tc->parent;
1353                 }
1354         }
1355         return NULL;
1356 }
1357
1358 /*
1359   show the parentage of a context
1360 */
1361 void talloc_show_parents(const void *context, FILE *file)
1362 {
1363         struct talloc_chunk *tc;
1364
1365         if (context == NULL) {
1366                 fprintf(file, "talloc no parents for NULL\n");
1367                 return;
1368         }
1369
1370         tc = talloc_chunk_from_ptr(context);
1371         fprintf(file, "talloc parents of '%s'\n", talloc_get_name(context));
1372         while (tc) {
1373                 fprintf(file, "\t'%s'\n", talloc_get_name(TC_PTR_FROM_CHUNK(tc)));
1374                 while (tc && tc->prev) tc = tc->prev;
1375                 if (tc) {
1376                         tc = tc->parent;
1377                 }
1378         }
1379         fflush(file);
1380 }
1381
1382 /*
1383   return 1 if ptr is a parent of context
1384 */
1385 int talloc_is_parent(const void *context, const void *ptr)
1386 {
1387         struct talloc_chunk *tc;
1388
1389         if (context == NULL) {
1390                 return 0;
1391         }
1392
1393         tc = talloc_chunk_from_ptr(context);
1394         while (tc) {
1395                 if (TC_PTR_FROM_CHUNK(tc) == ptr) return 1;
1396                 while (tc && tc->prev) tc = tc->prev;
1397                 if (tc) {
1398                         tc = tc->parent;
1399                 }
1400         }
1401         return 0;
1402 }