NOTE: Please read talloc_guide.txt for full documentation
Copyright (C) Andrew Tridgell 2004
+ Copyright (C) Stefan Metzmacher 2006
** NOTE! The following LGPL license applies to the talloc
** library. This does NOT imply that all of Samba is released
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
+ version 3 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
inspired by http://swapped.cc/halloc/
*/
-#include "config.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#ifdef HAVE_STDINT_H
-#include <stdint.h>
+#ifdef _SAMBA_BUILD_
+#include "version.h"
+#if (SAMBA_VERSION_MAJOR<4)
+#include "includes.h"
+/* This is to circumvent SAMBA3's paranoid malloc checker. Here in this file
+ * we trust ourselves... */
+#ifdef malloc
+#undef malloc
#endif
-
-#if defined(HAVE_STDARG_H)
-#include <stdarg.h>
-#elif defined (HAVE_VARARGS_H)
-#include <varargs.h>
-#else
-#error "no var arg header"
+#ifdef realloc
+#undef realloc
#endif
+#define _TALLOC_SAMBA3
+#endif /* (SAMBA_VERSION_MAJOR<4) */
+#endif /* _SAMBA_BUILD_ */
+#ifndef _TALLOC_SAMBA3
+#include "replace.h"
#include "talloc.h"
+#endif /* not _TALLOC_SAMBA3 */
/* use this to force every realloc to change the pointer, to stress test
code that might not cope */
#endif
#endif
+/* these macros gain us a few percent of speed on gcc */
+#if (__GNUC__ >= 3)
+/* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
+ as its first argument */
+#define likely(x) __builtin_expect(!!(x), 1)
+#define unlikely(x) __builtin_expect(!!(x), 0)
+#else
+#define likely(x) x
+#define unlikely(x) x
+#endif
+
/* this null_context is only used if talloc_enable_leak_report() or
talloc_enable_leak_report_full() is called, otherwise it remains
NULL
*/
-static const void *null_context;
-static void *cleanup_context;
-
+static void *null_context;
+static void *autofree_context;
struct talloc_reference_handle {
struct talloc_reference_handle *next, *prev;
#define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
/* panic if we get a bad magic value */
-static struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
+static inline struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
{
const char *pp = (const char *)ptr;
struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp - TC_HDR_SIZE);
- if ((tc->flags & ~0xF) != TALLOC_MAGIC) {
- TALLOC_ABORT("Bad talloc magic value - unknown value");
- }
- if (tc->flags & TALLOC_FLAG_FREE) {
- TALLOC_ABORT("Bad talloc magic value - double free");
+ if (unlikely((tc->flags & (TALLOC_FLAG_FREE | ~0xF)) != TALLOC_MAGIC)) {
+ if (tc->flags & TALLOC_FLAG_FREE) {
+ TALLOC_ABORT("Bad talloc magic value - double free");
+ } else {
+ TALLOC_ABORT("Bad talloc magic value - unknown value");
+ }
}
return tc;
}
/*
return the parent chunk of a pointer
*/
-static struct talloc_chunk *talloc_parent_chunk(const void *ptr)
+static inline struct talloc_chunk *talloc_parent_chunk(const void *ptr)
{
- struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
+ struct talloc_chunk *tc;
+
+ if (unlikely(ptr == NULL)) {
+ return NULL;
+ }
+
+ tc = talloc_chunk_from_ptr(ptr);
while (tc->prev) tc=tc->prev;
+
return tc->parent;
}
return tc? TC_PTR_FROM_CHUNK(tc) : NULL;
}
+/*
+ find parents name
+*/
+const char *talloc_parent_name(const void *ptr)
+{
+ struct talloc_chunk *tc = talloc_parent_chunk(ptr);
+ return tc? tc->name : NULL;
+}
+
/*
Allocate a bit of memory as a child of an existing pointer
*/
-void *_talloc(const void *context, size_t size)
+static inline void *__talloc(const void *context, size_t size)
{
struct talloc_chunk *tc;
- if (context == NULL) {
+ if (unlikely(context == NULL)) {
context = null_context;
}
- if (size >= MAX_TALLOC_SIZE) {
+ if (unlikely(size >= MAX_TALLOC_SIZE)) {
return NULL;
}
tc = (struct talloc_chunk *)malloc(TC_HDR_SIZE+size);
- if (tc == NULL) return NULL;
+ if (unlikely(tc == NULL)) return NULL;
tc->size = size;
tc->flags = TALLOC_MAGIC;
tc->name = NULL;
tc->refs = NULL;
- if (context) {
+ if (likely(context)) {
struct talloc_chunk *parent = talloc_chunk_from_ptr(context);
- tc->parent = parent;
-
if (parent->child) {
parent->child->parent = NULL;
+ tc->next = parent->child;
+ tc->next->prev = tc;
+ } else {
+ tc->next = NULL;
}
-
- _TLIST_ADD(parent->child, tc);
+ tc->parent = parent;
+ tc->prev = NULL;
+ parent->child = tc;
} else {
tc->next = tc->prev = tc->parent = NULL;
}
return TC_PTR_FROM_CHUNK(tc);
}
-
/*
setup a destructor to be called on free of a pointer
the destructor should return 0 on success, or -1 on failure.
/*
increase the reference count on a piece of memory.
*/
-void talloc_increase_ref_count(const void *ptr)
+int talloc_increase_ref_count(const void *ptr)
{
- talloc_reference(null_context, ptr);
+ if (unlikely(!talloc_reference(null_context, ptr))) {
+ return -1;
+ }
+ return 0;
}
/*
helper for talloc_reference()
+
+ this is referenced by a function pointer and should not be inline
*/
static int talloc_reference_destructor(struct talloc_reference_handle *handle)
{
return 0;
}
+/*
+ more efficient way to add a name to a pointer - the name must point to a
+ true string constant
+*/
+static inline void _talloc_set_name_const(const void *ptr, const char *name)
+{
+ struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
+ tc->name = name;
+}
+
+/*
+ internal talloc_named_const()
+*/
+static inline void *_talloc_named_const(const void *context, size_t size, const char *name)
+{
+ void *ptr;
+
+ ptr = __talloc(context, size);
+ if (unlikely(ptr == NULL)) {
+ return NULL;
+ }
+
+ _talloc_set_name_const(ptr, name);
+
+ return ptr;
+}
+
/*
make a secondary reference to a pointer, hanging off the given context.
the pointer remains valid until both the original caller and this given
same underlying data, and you want to be able to free the two instances separately,
and in either order
*/
-void *talloc_reference(const void *context, const void *ptr)
+void *_talloc_reference(const void *context, const void *ptr)
{
struct talloc_chunk *tc;
struct talloc_reference_handle *handle;
- if (ptr == NULL) return NULL;
+ if (unlikely(ptr == NULL)) return NULL;
tc = talloc_chunk_from_ptr(ptr);
- handle = (struct talloc_reference_handle *)talloc_named_const(context,
+ handle = (struct talloc_reference_handle *)_talloc_named_const(context,
sizeof(struct talloc_reference_handle),
TALLOC_MAGIC_REFERENCE);
- if (handle == NULL) return NULL;
+ if (unlikely(handle == NULL)) return NULL;
/* note that we hang the destructor off the handle, not the
main context as that allows the caller to still setup their
return handle->ptr;
}
+
+/*
+ internal talloc_free call
+*/
+static inline int _talloc_free(void *ptr)
+{
+ struct talloc_chunk *tc;
+
+ if (unlikely(ptr == NULL)) {
+ return -1;
+ }
+
+ tc = talloc_chunk_from_ptr(ptr);
+
+ if (unlikely(tc->refs)) {
+ int is_child;
+ /* check this is a reference from a child or grantchild
+ * back to it's parent or grantparent
+ *
+ * in that case we need to remove the reference and
+ * call another instance of talloc_free() on the current
+ * pointer.
+ */
+ is_child = talloc_is_parent(tc->refs, ptr);
+ _talloc_free(tc->refs);
+ if (is_child) {
+ return _talloc_free(ptr);
+ }
+ return -1;
+ }
+
+ if (unlikely(tc->flags & TALLOC_FLAG_LOOP)) {
+ /* we have a free loop - stop looping */
+ return 0;
+ }
+
+ if (unlikely(tc->destructor)) {
+ talloc_destructor_t d = tc->destructor;
+ if (d == (talloc_destructor_t)-1) {
+ return -1;
+ }
+ tc->destructor = (talloc_destructor_t)-1;
+ if (d(ptr) == -1) {
+ tc->destructor = d;
+ return -1;
+ }
+ tc->destructor = NULL;
+ }
+
+ if (tc->parent) {
+ _TLIST_REMOVE(tc->parent->child, tc);
+ if (tc->parent->child) {
+ tc->parent->child->parent = tc->parent;
+ }
+ } else {
+ if (tc->prev) tc->prev->next = tc->next;
+ if (tc->next) tc->next->prev = tc->prev;
+ }
+
+ tc->flags |= TALLOC_FLAG_LOOP;
+
+ while (tc->child) {
+ /* we need to work out who will own an abandoned child
+ if it cannot be freed. In priority order, the first
+ choice is owner of any remaining reference to this
+ pointer, the second choice is our parent, and the
+ final choice is the null context. */
+ void *child = TC_PTR_FROM_CHUNK(tc->child);
+ const void *new_parent = null_context;
+ if (unlikely(tc->child->refs)) {
+ struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
+ if (p) new_parent = TC_PTR_FROM_CHUNK(p);
+ }
+ if (unlikely(_talloc_free(child) == -1)) {
+ if (new_parent == null_context) {
+ struct talloc_chunk *p = talloc_parent_chunk(ptr);
+ if (p) new_parent = TC_PTR_FROM_CHUNK(p);
+ }
+ talloc_steal(new_parent, child);
+ }
+ }
+
+ tc->flags |= TALLOC_FLAG_FREE;
+ free(tc);
+ return 0;
+}
+
+/*
+ move a lump of memory from one talloc context to another return the
+ ptr on success, or NULL if it could not be transferred.
+ passing NULL as ptr will always return NULL with no side effects.
+*/
+void *_talloc_steal(const void *new_ctx, const void *ptr)
+{
+ struct talloc_chunk *tc, *new_tc;
+
+ if (unlikely(!ptr)) {
+ return NULL;
+ }
+
+ if (unlikely(new_ctx == NULL)) {
+ new_ctx = null_context;
+ }
+
+ tc = talloc_chunk_from_ptr(ptr);
+
+ if (unlikely(new_ctx == NULL)) {
+ if (tc->parent) {
+ _TLIST_REMOVE(tc->parent->child, tc);
+ if (tc->parent->child) {
+ tc->parent->child->parent = tc->parent;
+ }
+ } else {
+ if (tc->prev) tc->prev->next = tc->next;
+ if (tc->next) tc->next->prev = tc->prev;
+ }
+
+ tc->parent = tc->next = tc->prev = NULL;
+ return discard_const_p(void, ptr);
+ }
+
+ new_tc = talloc_chunk_from_ptr(new_ctx);
+
+ if (unlikely(tc == new_tc || tc->parent == new_tc)) {
+ return discard_const_p(void, ptr);
+ }
+
+ if (tc->parent) {
+ _TLIST_REMOVE(tc->parent->child, tc);
+ if (tc->parent->child) {
+ tc->parent->child->parent = tc->parent;
+ }
+ } else {
+ if (tc->prev) tc->prev->next = tc->next;
+ if (tc->next) tc->next->prev = tc->prev;
+ }
+
+ tc->parent = new_tc;
+ if (new_tc->child) new_tc->child->parent = NULL;
+ _TLIST_ADD(new_tc->child, tc);
+
+ return discard_const_p(void, ptr);
+}
+
+
+
/*
remove a secondary reference to a pointer. This undo's what
talloc_reference() has done. The context and pointer arguments
must match those given to a talloc_reference()
*/
-static int talloc_unreference(const void *context, const void *ptr)
+static inline int talloc_unreference(const void *context, const void *ptr)
{
struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
struct talloc_reference_handle *h;
- if (context == NULL) {
+ if (unlikely(context == NULL)) {
context = null_context;
}
return -1;
}
- return talloc_free(h);
+ return _talloc_free(h);
}
/*
tc_p = talloc_chunk_from_ptr(ptr);
if (tc_p->refs == NULL) {
- return talloc_free(ptr);
+ return _talloc_free(ptr);
}
new_p = talloc_parent_chunk(tc_p->refs);
/*
add a name to an existing pointer - va_list version
*/
-static const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
-static const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
+static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
{
struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
tc->name = talloc_vasprintf(ptr, fmt, ap);
- if (tc->name) {
- talloc_set_name_const(tc->name, ".name");
+ if (likely(tc->name)) {
+ _talloc_set_name_const(tc->name, ".name");
}
return tc->name;
}
return name;
}
-/*
- more efficient way to add a name to a pointer - the name must point to a
- true string constant
-*/
-void talloc_set_name_const(const void *ptr, const char *name)
-{
- struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
- tc->name = name;
-}
/*
create a named talloc pointer. Any talloc pointer can be named, and
void *ptr;
const char *name;
- ptr = _talloc(context, size);
- if (ptr == NULL) return NULL;
+ ptr = __talloc(context, size);
+ if (unlikely(ptr == NULL)) return NULL;
va_start(ap, fmt);
name = talloc_set_name_v(ptr, fmt, ap);
va_end(ap);
- if (name == NULL) {
- talloc_free(ptr);
+ if (unlikely(name == NULL)) {
+ _talloc_free(ptr);
return NULL;
}
return ptr;
}
-/*
- create a named talloc pointer. Any talloc pointer can be named, and
- talloc_named() operates just like talloc() except that it allows you
- to name the pointer.
-*/
-void *talloc_named_const(const void *context, size_t size, const char *name)
-{
- void *ptr;
-
- ptr = _talloc(context, size);
- if (ptr == NULL) {
- return NULL;
- }
-
- talloc_set_name_const(ptr, name);
-
- return ptr;
-}
-
/*
return the name of a talloc ptr, or "UNNAMED"
*/
const char *talloc_get_name(const void *ptr)
{
struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
- if (tc->name == TALLOC_MAGIC_REFERENCE) {
+ if (unlikely(tc->name == TALLOC_MAGIC_REFERENCE)) {
return ".reference";
}
- if (tc->name) {
+ if (likely(tc->name)) {
return tc->name;
}
return "UNNAMED";
void *talloc_check_name(const void *ptr, const char *name)
{
const char *pname;
- if (ptr == NULL) return NULL;
+ if (unlikely(ptr == NULL)) return NULL;
pname = talloc_get_name(ptr);
- if (pname == name || strcmp(pname, name) == 0) {
+ if (likely(pname == name || strcmp(pname, name) == 0)) {
return discard_const_p(void, ptr);
}
return NULL;
void *ptr;
const char *name;
- ptr = _talloc(NULL, 0);
- if (ptr == NULL) return NULL;
+ /*
+ * samba3 expects talloc_report_depth_cb(NULL, ...)
+ * reports all talloc'ed memory, so we need to enable
+ * null_tracking
+ */
+ talloc_enable_null_tracking();
+
+ ptr = __talloc(NULL, 0);
+ if (unlikely(ptr == NULL)) return NULL;
va_start(ap, fmt);
name = talloc_set_name_v(ptr, fmt, ap);
va_end(ap);
- if (name == NULL) {
- talloc_free(ptr);
+ if (unlikely(name == NULL)) {
+ _talloc_free(ptr);
return NULL;
}
{
struct talloc_chunk *tc;
- if (ptr == NULL) {
+ if (unlikely(ptr == NULL)) {
return;
}
final choice is the null context. */
void *child = TC_PTR_FROM_CHUNK(tc->child);
const void *new_parent = null_context;
- if (tc->child->refs) {
+ if (unlikely(tc->child->refs)) {
struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
if (p) new_parent = TC_PTR_FROM_CHUNK(p);
}
- if (talloc_free(child) == -1) {
+ if (unlikely(_talloc_free(child) == -1)) {
if (new_parent == null_context) {
struct talloc_chunk *p = talloc_parent_chunk(ptr);
if (p) new_parent = TC_PTR_FROM_CHUNK(p);
}
}
+/*
+ Allocate a bit of memory as a child of an existing pointer
+*/
+void *_talloc(const void *context, size_t size)
+{
+ return __talloc(context, size);
+}
+
+/*
+ externally callable talloc_set_name_const()
+*/
+void talloc_set_name_const(const void *ptr, const char *name)
+{
+ _talloc_set_name_const(ptr, name);
+}
+
+/*
+ create a named talloc pointer. Any talloc pointer can be named, and
+ talloc_named() operates just like talloc() except that it allows you
+ to name the pointer.
+*/
+void *talloc_named_const(const void *context, size_t size, const char *name)
+{
+ return _talloc_named_const(context, size, name);
+}
+
/*
free a talloc pointer. This also frees all child pointers of this
pointer recursively
*/
int talloc_free(void *ptr)
{
- struct talloc_chunk *tc;
- int old_errno;
-
- if (ptr == NULL) {
- return -1;
- }
-
- tc = talloc_chunk_from_ptr(ptr);
-
- if (tc->refs) {
- int is_child;
- /* check this is a reference from a child or grantchild
- * back to it's parent or grantparent
- *
- * in that case we need to remove the reference and
- * call another instance of talloc_free() on the current
- * pointer.
- */
- is_child = talloc_is_parent(tc->refs, ptr);
- talloc_free(tc->refs);
- if (is_child) {
- return talloc_free(ptr);
- }
- return -1;
- }
-
- if (tc->flags & TALLOC_FLAG_LOOP) {
- /* we have a free loop - stop looping */
- return 0;
- }
-
- if (tc->destructor) {
- talloc_destructor_t d = tc->destructor;
- if (d == (talloc_destructor_t)-1) {
- return -1;
- }
- tc->destructor = (talloc_destructor_t)-1;
- if (d(ptr) == -1) {
- tc->destructor = d;
- return -1;
- }
- tc->destructor = NULL;
- }
-
- if (tc->parent) {
- _TLIST_REMOVE(tc->parent->child, tc);
- if (tc->parent->child) {
- tc->parent->child->parent = tc->parent;
- }
- } else {
- if (tc->prev) tc->prev->next = tc->next;
- if (tc->next) tc->next->prev = tc->prev;
- }
-
- tc->flags |= TALLOC_FLAG_LOOP;
- talloc_free_children(ptr);
-
- tc->flags |= TALLOC_FLAG_FREE;
- old_errno = errno;
- free(tc);
- errno = old_errno;
- return 0;
+ return _talloc_free(ptr);
}
void *new_ptr;
/* size zero is equivalent to free() */
- if (size == 0) {
- talloc_free(ptr);
+ if (unlikely(size == 0)) {
+ _talloc_free(ptr);
return NULL;
}
- if (size >= MAX_TALLOC_SIZE) {
+ if (unlikely(size >= MAX_TALLOC_SIZE)) {
return NULL;
}
- /* realloc(NULL) is equavalent to malloc() */
+ /* realloc(NULL) is equivalent to malloc() */
if (ptr == NULL) {
- return talloc_named_const(context, size, name);
+ return _talloc_named_const(context, size, name);
}
tc = talloc_chunk_from_ptr(ptr);
/* don't allow realloc on referenced pointers */
- if (tc->refs) {
+ if (unlikely(tc->refs)) {
return NULL;
}
#else
new_ptr = realloc(tc, size + TC_HDR_SIZE);
#endif
- if (!new_ptr) {
+ if (unlikely(!new_ptr)) {
tc->flags &= ~TALLOC_FLAG_FREE;
return NULL;
}
}
tc->size = size;
- talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
+ _talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
return TC_PTR_FROM_CHUNK(tc);
}
-/*
- move a lump of memory from one talloc context to another return the
- ptr on success, or NULL if it could not be transferred.
- passing NULL as ptr will always return NULL with no side effects.
+/*
+ a wrapper around talloc_steal() for situations where you are moving a pointer
+ between two structures, and want the old pointer to be set to NULL
*/
-void *_talloc_steal(const void *new_ctx, const void *ptr)
+void *_talloc_move(const void *new_ctx, const void *_pptr)
{
- struct talloc_chunk *tc, *new_tc;
-
- if (!ptr) {
- return NULL;
- }
-
- if (new_ctx == NULL) {
- new_ctx = null_context;
- }
-
- tc = talloc_chunk_from_ptr(ptr);
-
- if (new_ctx == NULL) {
- if (tc->parent) {
- _TLIST_REMOVE(tc->parent->child, tc);
- if (tc->parent->child) {
- tc->parent->child->parent = tc->parent;
- }
- } else {
- if (tc->prev) tc->prev->next = tc->next;
- if (tc->next) tc->next->prev = tc->prev;
- }
-
- tc->parent = tc->next = tc->prev = NULL;
- return discard_const_p(void, ptr);
- }
-
- new_tc = talloc_chunk_from_ptr(new_ctx);
-
- if (tc == new_tc || tc->parent == new_tc) {
- return discard_const_p(void, ptr);
- }
-
- if (tc->parent) {
- _TLIST_REMOVE(tc->parent->child, tc);
- if (tc->parent->child) {
- tc->parent->child->parent = tc->parent;
- }
- } else {
- if (tc->prev) tc->prev->next = tc->next;
- if (tc->next) tc->next->prev = tc->prev;
- }
-
- tc->parent = new_tc;
- if (new_tc->child) new_tc->child->parent = NULL;
- _TLIST_ADD(new_tc->child, tc);
-
- return discard_const_p(void, ptr);
+ const void **pptr = discard_const_p(const void *,_pptr);
+ void *ret = _talloc_steal(new_ctx, *pptr);
+ (*pptr) = NULL;
+ return ret;
}
/*
/*
return the number of external references to a pointer
*/
-static int talloc_reference_count(const void *ptr)
+size_t talloc_reference_count(const void *ptr)
{
struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
struct talloc_reference_handle *h;
- int ret = 0;
+ size_t ret = 0;
for (h=tc->refs;h;h=h->next) {
ret++;
/*
report on memory usage by all children of a pointer, giving a full tree view
*/
-void talloc_report_depth(const void *ptr, FILE *f, int depth)
+void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
+ void (*callback)(const void *ptr,
+ int depth, int max_depth,
+ int is_ref,
+ void *private_data),
+ void *private_data)
{
- struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
+ struct talloc_chunk *c, *tc;
+
+ if (ptr == NULL) {
+ ptr = null_context;
+ }
+ if (ptr == NULL) return;
+
+ tc = talloc_chunk_from_ptr(ptr);
if (tc->flags & TALLOC_FLAG_LOOP) {
return;
}
- tc->flags |= TALLOC_FLAG_LOOP;
+ callback(ptr, depth, max_depth, 0, private_data);
+ if (max_depth >= 0 && depth >= max_depth) {
+ return;
+ }
+
+ tc->flags |= TALLOC_FLAG_LOOP;
for (c=tc->child;c;c=c->next) {
if (c->name == TALLOC_MAGIC_REFERENCE) {
- struct talloc_reference_handle *handle = TC_PTR_FROM_CHUNK(c);
- const char *name2 = talloc_get_name(handle->ptr);
- fprintf(f, "%*sreference to: %s\n", depth*4, "", name2);
+ struct talloc_reference_handle *h = (struct talloc_reference_handle *)TC_PTR_FROM_CHUNK(c);
+ callback(h->ptr, depth + 1, max_depth, 1, private_data);
} else {
- const char *name = talloc_get_name(TC_PTR_FROM_CHUNK(c));
- fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d)\n",
- depth*4, "",
- name,
- (unsigned long)talloc_total_size(TC_PTR_FROM_CHUNK(c)),
- (unsigned long)talloc_total_blocks(TC_PTR_FROM_CHUNK(c)),
- talloc_reference_count(TC_PTR_FROM_CHUNK(c)));
- talloc_report_depth(TC_PTR_FROM_CHUNK(c), f, depth+1);
+ talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c), depth + 1, max_depth, callback, private_data);
}
}
tc->flags &= ~TALLOC_FLAG_LOOP;
}
-/*
- report on memory usage by all children of a pointer, giving a full tree view
-*/
-void talloc_report_full(const void *ptr, FILE *f)
+static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_depth, int is_ref, void *_f)
{
- if (ptr == NULL) {
- ptr = null_context;
+ const char *name = talloc_get_name(ptr);
+ FILE *f = (FILE *)_f;
+
+ if (is_ref) {
+ fprintf(f, "%*sreference to: %s\n", depth*4, "", name);
+ return;
}
- if (ptr == NULL) return;
- fprintf(f,"full talloc report on '%s' (total %lu bytes in %lu blocks)\n",
- talloc_get_name(ptr),
+ if (depth == 0) {
+ fprintf(f,"%stalloc report on '%s' (total %6lu bytes in %3lu blocks)\n",
+ (max_depth < 0 ? "full " :""), name,
+ (unsigned long)talloc_total_size(ptr),
+ (unsigned long)talloc_total_blocks(ptr));
+ return;
+ }
+
+ fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d) %p\n",
+ depth*4, "",
+ name,
(unsigned long)talloc_total_size(ptr),
- (unsigned long)talloc_total_blocks(ptr));
+ (unsigned long)talloc_total_blocks(ptr),
+ (int)talloc_reference_count(ptr), ptr);
+
+#if 0
+ fprintf(f, "content: ");
+ if (talloc_total_size(ptr)) {
+ int tot = talloc_total_size(ptr);
+ int i;
+
+ for (i = 0; i < tot; i++) {
+ if ((((char *)ptr)[i] > 31) && (((char *)ptr)[i] < 126)) {
+ fprintf(f, "%c", ((char *)ptr)[i]);
+ } else {
+ fprintf(f, "~%02x", ((char *)ptr)[i]);
+ }
+ }
+ }
+ fprintf(f, "\n");
+#endif
+}
- talloc_report_depth(ptr, f, 1);
+/*
+ report on memory usage by all children of a pointer, giving a full tree view
+*/
+void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f)
+{
+ talloc_report_depth_cb(ptr, depth, max_depth, talloc_report_depth_FILE_helper, f);
fflush(f);
}
+/*
+ report on memory usage by all children of a pointer, giving a full tree view
+*/
+void talloc_report_full(const void *ptr, FILE *f)
+{
+ talloc_report_depth_file(ptr, 0, -1, f);
+}
+
/*
report on memory usage by all children of a pointer
*/
void talloc_report(const void *ptr, FILE *f)
{
- struct talloc_chunk *c, *tc;
-
- if (ptr == NULL) {
- ptr = null_context;
- }
- if (ptr == NULL) return;
-
- fprintf(f,"talloc report on '%s' (total %lu bytes in %lu blocks)\n",
- talloc_get_name(ptr),
- (unsigned long)talloc_total_size(ptr),
- (unsigned long)talloc_total_blocks(ptr));
-
- tc = talloc_chunk_from_ptr(ptr);
-
- for (c=tc->child;c;c=c->next) {
- fprintf(f, "\t%-30s contains %6lu bytes in %3lu blocks\n",
- talloc_get_name(TC_PTR_FROM_CHUNK(c)),
- (unsigned long)talloc_total_size(TC_PTR_FROM_CHUNK(c)),
- (unsigned long)talloc_total_blocks(TC_PTR_FROM_CHUNK(c)));
- }
- fflush(f);
+ talloc_report_depth_file(ptr, 0, 1, f);
}
/*
void talloc_enable_null_tracking(void)
{
if (null_context == NULL) {
- null_context = talloc_named_const(NULL, 0, "null_context");
+ null_context = _talloc_named_const(NULL, 0, "null_context");
}
}
+/*
+ disable tracking of the NULL context
+*/
+void talloc_disable_null_tracking(void)
+{
+ _talloc_free(null_context);
+ null_context = NULL;
+}
+
/*
enable leak reporting on exit
*/
*/
void *_talloc_zero(const void *ctx, size_t size, const char *name)
{
- void *p = talloc_named_const(ctx, size, name);
+ void *p = _talloc_named_const(ctx, size, name);
if (p) {
memset(p, '\0', size);
return p;
}
-
/*
memdup with a talloc.
*/
void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
{
- void *newp = talloc_named_const(t, size, name);
+ void *newp = _talloc_named_const(t, size, name);
- if (newp) {
+ if (likely(newp)) {
memcpy(newp, p, size);
}
return NULL;
}
ret = (char *)talloc_memdup(t, p, strlen(p) + 1);
- if (ret) {
- talloc_set_name_const(ret, ret);
+ if (likely(ret)) {
+ _talloc_set_name_const(ret, ret);
}
return ret;
}
/* append the string with the trailing \0 */
memcpy(&ret[olen], append, alenz);
+ _talloc_set_name_const(ret, ret);
+
return ret;
}
for (len=0; len<n && p[len]; len++) ;
- ret = (char *)_talloc(t, len + 1);
+ ret = (char *)__talloc(t, len + 1);
if (!ret) { return NULL; }
memcpy(ret, p, len);
ret[len] = 0;
- talloc_set_name_const(ret, ret);
+ _talloc_set_name_const(ret, ret);
return ret;
}
va_list ap2;
char c;
- va_copy(ap2, ap);
-
/* this call looks strange, but it makes it work on older solaris boxes */
- if ((len = vsnprintf(&c, 1, fmt, ap2)) < 0) {
+ va_copy(ap2, ap);
+ len = vsnprintf(&c, 1, fmt, ap2);
+ va_end(ap2);
+ if (len < 0) {
return NULL;
}
- ret = (char *)_talloc(t, len+1);
+ ret = (char *)__talloc(t, len+1);
if (ret) {
va_copy(ap2, ap);
vsnprintf(ret, len+1, fmt, ap2);
- talloc_set_name_const(ret, ret);
+ va_end(ap2);
+ _talloc_set_name_const(ret, ret);
}
return ret;
tc = talloc_chunk_from_ptr(s);
+ s_len = tc->size - 1;
+
va_copy(ap2, ap);
+ len = vsnprintf(&c, 1, fmt, ap2);
+ va_end(ap2);
- s_len = tc->size - 1;
- if ((len = vsnprintf(&c, 1, fmt, ap2)) <= 0) {
+ if (len <= 0) {
/* Either the vsnprintf failed or the format resulted in
* no characters being formatted. In the former case, we
* ought to return NULL, in the latter we ought to return
if (!s) return NULL;
va_copy(ap2, ap);
-
vsnprintf(s+s_len, len+1, fmt, ap2);
- talloc_set_name_const(s, s);
+ va_end(ap2);
+ _talloc_set_name_const(s, s);
return s;
}
if (count >= MAX_TALLOC_SIZE/el_size) {
return NULL;
}
- return talloc_named_const(ctx, el_size * count, name);
+ return _talloc_named_const(ctx, el_size * count, name);
}
/*
return _talloc_zero(ctx, el_size * count, name);
}
-
/*
realloc an array, checking for integer overflow in the array size
*/
}
+static int talloc_autofree_destructor(void *ptr)
+{
+ autofree_context = NULL;
+ return 0;
+}
+
static void talloc_autofree(void)
{
- talloc_free(cleanup_context);
- cleanup_context = NULL;
+ _talloc_free(autofree_context);
}
/*
*/
void *talloc_autofree_context(void)
{
- if (cleanup_context == NULL) {
- cleanup_context = talloc_named_const(NULL, 0, "autofree_context");
+ if (autofree_context == NULL) {
+ autofree_context = _talloc_named_const(NULL, 0, "autofree_context");
+ talloc_set_destructor(autofree_context, talloc_autofree_destructor);
atexit(talloc_autofree);
}
- return cleanup_context;
+ return autofree_context;
}
size_t talloc_get_size(const void *context)
tc = tc->parent;
}
}
+ fflush(file);
}
/*