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