/*

   Samba Unix SMB/CIFS implementation.

   Samba trivial allocation library - new interface

   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

     ** under the LGPL

   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 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

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with this library; if not, see <http://www.gnu.org/licenses/>.

*/

/*

  inspired by http://swapped.cc/halloc/

*/

#include "replace.h"

#include "talloc.h"

#ifdef HAVE_SYS_AUXV_H

#include <sys/auxv.h>

#endif

#if (TALLOC_VERSION_MAJOR != TALLOC_BUILD_VERSION_MAJOR)

#error "TALLOC_VERSION_MAJOR != TALLOC_BUILD_VERSION_MAJOR"

#endif

#if (TALLOC_VERSION_MINOR != TALLOC_BUILD_VERSION_MINOR)

#error "TALLOC_VERSION_MINOR != TALLOC_BUILD_VERSION_MINOR"

#endif

/* Special macros that are no-ops except when run under Valgrind on

 * x86.  They've moved a little bit from valgrind 1.0.4 to 1.9.4 */

#ifdef HAVE_VALGRIND_MEMCHECK_H

        /* memcheck.h includes valgrind.h */

#include <valgrind/memcheck.h>

#elif defined(HAVE_VALGRIND_H)

#include <valgrind.h>

#endif

/* use this to force every realloc to change the pointer, to stress test

   code that might not cope */

#define ALWAYS_REALLOC 0

#define MAX_TALLOC_SIZE 0x10000000

#define TALLOC_FLAG_FREE 0x01

#define TALLOC_FLAG_LOOP 0x02

#define TALLOC_FLAG_POOL 0x04		/* This is a talloc pool */

#define TALLOC_FLAG_POOLMEM 0x08	/* This is allocated in a pool */

/*

 * Bits above this are random, used to make it harder to fake talloc

 * headers during an attack.  Try not to change this without good reason.

 */

#define TALLOC_FLAG_MASK 0x0F

#define TALLOC_MAGIC_REFERENCE ((const char *)1)

#define TALLOC_MAGIC_BASE 0xe814ec70

#define TALLOC_MAGIC_NON_RANDOM ( \

	~TALLOC_FLAG_MASK & ( \

		TALLOC_MAGIC_BASE + \

		(TALLOC_BUILD_VERSION_MAJOR << 24) + \

		(TALLOC_BUILD_VERSION_MINOR << 16) + \

		(TALLOC_BUILD_VERSION_RELEASE << 8)))

static unsigned int talloc_magic = TALLOC_MAGIC_NON_RANDOM;

/* by default we abort when given a bad pointer (such as when talloc_free() is called

   on a pointer that came from malloc() */

#ifndef TALLOC_ABORT

#define TALLOC_ABORT(reason) abort()

#endif

#ifndef discard_const_p

#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)

# define discard_const_p(type, ptr) ((type *)((intptr_t)(ptr)))

#else

# define discard_const_p(type, ptr) ((type *)(ptr))

#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 */

#ifndef likely

#define likely(x)   __builtin_expect(!!(x), 1)

#endif

#ifndef unlikely

#define unlikely(x) __builtin_expect(!!(x), 0)

#endif

#else

#ifndef likely

#define likely(x) (x)

#endif

#ifndef unlikely

#define unlikely(x) (x)

#endif

#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 void *null_context;

static bool talloc_report_null;

static bool talloc_report_null_full;

static void *autofree_context;

static void talloc_setup_atexit(void);

/* used to enable fill of memory on free, which can be useful for

 * catching use after free errors when valgrind is too slow

 */

static struct {

	bool initialised;

	bool enabled;

	uint8_t fill_value;

} talloc_fill;

#define TALLOC_FILL_ENV "TALLOC_FREE_FILL"

/*

 * do not wipe the header, to allow the

 * double-free logic to still work

 */

#define TC_INVALIDATE_FULL_FILL_CHUNK(_tc) do { \

	if (unlikely(talloc_fill.enabled)) { \

		size_t _flen = (_tc)->size; \

		char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \

		memset(_fptr, talloc_fill.fill_value, _flen); \

	} \

} while (0)

#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)

/* Mark the whole chunk as not accessable */

#define TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc) do { \

	size_t _flen = TC_HDR_SIZE + (_tc)->size; \

	char *_fptr = (char *)(_tc); \

	VALGRIND_MAKE_MEM_NOACCESS(_fptr, _flen); \

} while(0)

#else

#define TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc) do { } while (0)

#endif

#define TC_INVALIDATE_FULL_CHUNK(_tc) do { \

	TC_INVALIDATE_FULL_FILL_CHUNK(_tc); \

	TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc); \

} while (0)

#define TC_INVALIDATE_SHRINK_FILL_CHUNK(_tc, _new_size) do { \

	if (unlikely(talloc_fill.enabled)) { \

		size_t _flen = (_tc)->size - (_new_size); \

		char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \

		_fptr += (_new_size); \

		memset(_fptr, talloc_fill.fill_value, _flen); \

	} \

} while (0)

#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)

/* Mark the unused bytes not accessable */

#define TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { \

	size_t _flen = (_tc)->size - (_new_size); \

	char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \

	_fptr += (_new_size); \

	VALGRIND_MAKE_MEM_NOACCESS(_fptr, _flen); \

} while (0)

#else

#define TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)

#endif

#define TC_INVALIDATE_SHRINK_CHUNK(_tc, _new_size) do { \

	TC_INVALIDATE_SHRINK_FILL_CHUNK(_tc, _new_size); \

	TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size); \

} while (0)

#define TC_UNDEFINE_SHRINK_FILL_CHUNK(_tc, _new_size) do { \

	if (unlikely(talloc_fill.enabled)) { \

		size_t _flen = (_tc)->size - (_new_size); \

		char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \

		_fptr += (_new_size); \

		memset(_fptr, talloc_fill.fill_value, _flen); \

	} \

} while (0)

#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)

/* Mark the unused bytes as undefined */

#define TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { \

	size_t _flen = (_tc)->size - (_new_size); \

	char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \

	_fptr += (_new_size); \

	VALGRIND_MAKE_MEM_UNDEFINED(_fptr, _flen); \

} while (0)

#else

#define TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)

#endif

#define TC_UNDEFINE_SHRINK_CHUNK(_tc, _new_size) do { \

	TC_UNDEFINE_SHRINK_FILL_CHUNK(_tc, _new_size); \

	TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size); \

} while (0)

#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)

/* Mark the new bytes as undefined */

#define TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size) do { \

	size_t _old_used = TC_HDR_SIZE + (_tc)->size; \

	size_t _new_used = TC_HDR_SIZE + (_new_size); \

	size_t _flen = _new_used - _old_used; \

	char *_fptr = _old_used + (char *)(_tc); \

	VALGRIND_MAKE_MEM_UNDEFINED(_fptr, _flen); \

} while (0)

#else

#define TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)

#endif

#define TC_UNDEFINE_GROW_CHUNK(_tc, _new_size) do { \

	TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size); \

} while (0)

struct talloc_reference_handle {

	struct talloc_reference_handle *next, *prev;

	void *ptr;

	const char *location;

};

struct talloc_memlimit {

	struct talloc_chunk *parent;

	struct talloc_memlimit *upper;

	size_t max_size;

	size_t cur_size;

};

static inline bool talloc_memlimit_check(struct talloc_memlimit *limit, size_t size);

static inline void talloc_memlimit_grow(struct talloc_memlimit *limit,

				size_t size);

static inline void talloc_memlimit_shrink(struct talloc_memlimit *limit,

				size_t size);

static inline void tc_memlimit_update_on_free(struct talloc_chunk *tc);

static inline void _tc_set_name_const(struct talloc_chunk *tc,

				const char *name);

static struct talloc_chunk *_vasprintf_tc(const void *t,

				const char *fmt,

				va_list ap);

typedef int (*talloc_destructor_t)(void *);

struct talloc_pool_hdr;

struct talloc_chunk {

	/*

	 * flags includes the talloc magic, which is randomised to

	 * make overwrite attacks harder

	 */

	unsigned flags;

	/*

	 * If you have a logical tree like:

	 *

	 *           <parent>

	 *           /   |   \

	 *          /    |    \

	 *         /     |     \

	 * <child 1> <child 2> <child 3>

	 *

	 * The actual talloc tree is:

	 *

	 *  <parent>

	 *     |

	 *  <child 1> - <child 2> - <child 3>

	 *

	 * The children are linked with next/prev pointers, and

	 * child 1 is linked to the parent with parent/child

	 * pointers.

	 */

	struct talloc_chunk *next, *prev;

	struct talloc_chunk *parent, *child;

	struct talloc_reference_handle *refs;

	talloc_destructor_t destructor;

	const char *name;

	size_t size;

	/*

	 * limit semantics:

	 * if 'limit' is set it means all *new* children of the context will

	 * be limited to a total aggregate size ox max_size for memory

	 * allocations.

	 * cur_size is used to keep track of the current use

	 */

	struct talloc_memlimit *limit;

	/*

	 * For members of a pool (i.e. TALLOC_FLAG_POOLMEM is set), "pool"

	 * is a pointer to the struct talloc_chunk of the pool that it was

	 * allocated from. This way children can quickly find the pool to chew

	 * from.

	 */

	struct talloc_pool_hdr *pool;

};

union talloc_chunk_cast_u {

	uint8_t *ptr;

	struct talloc_chunk *chunk;

};

/* 16 byte alignment seems to keep everyone happy */

#define TC_ALIGN16(s) (((s)+15)&~15)

#define TC_HDR_SIZE TC_ALIGN16(sizeof(struct talloc_chunk))

#define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))

_PUBLIC_ int talloc_version_major(void)

{

	return TALLOC_VERSION_MAJOR;

}

_PUBLIC_ int talloc_version_minor(void)

{

	return TALLOC_VERSION_MINOR;

}

_PUBLIC_ int talloc_test_get_magic(void)

{

	return talloc_magic;

}

static inline void _talloc_chunk_set_free(struct talloc_chunk *tc,

			      const char *location)

{

	/*

	 * Mark this memory as free, and also over-stamp the talloc

	 * magic with the old-style magic.

	 *

	 * Why?  This tries to avoid a memory read use-after-free from

	 * disclosing our talloc magic, which would then allow an

	 * attacker to prepare a valid header and so run a destructor.

	 *

	 */

	tc->flags = TALLOC_MAGIC_NON_RANDOM | TALLOC_FLAG_FREE

		| (tc->flags & TALLOC_FLAG_MASK);

	/* we mark the freed memory with where we called the free

	 * from. This means on a double free error we can report where

	 * the first free came from

	 */

	if (location) {

		tc->name = location;

	}

}

static inline void _talloc_chunk_set_not_free(struct talloc_chunk *tc)

{

	/*

	 * Mark this memory as not free.

	 *

	 * Why? This is memory either in a pool (and so available for

	 * talloc's re-use or after the realloc().  We need to mark

	 * the memory as free() before any realloc() call as we can't

	 * write to the memory after that.

	 *

	 * We put back the normal magic instead of the 'not random'

	 * magic.

	 */

	tc->flags = talloc_magic |

		((tc->flags & TALLOC_FLAG_MASK) & ~TALLOC_FLAG_FREE);

}

static void (*talloc_log_fn)(const char *message);

_PUBLIC_ void talloc_set_log_fn(void (*log_fn)(const char *message))

{

	talloc_log_fn = log_fn;

}

#ifdef HAVE_CONSTRUCTOR_ATTRIBUTE

void talloc_lib_init(void) __attribute__((constructor));

void talloc_lib_init(void)

{

	uint32_t random_value;

#if defined(HAVE_GETAUXVAL) && defined(AT_RANDOM)

	uint8_t *p;

	/*

	 * Use the kernel-provided random values used for

	 * ASLR.  This won't change per-exec, which is ideal for us

	 */

	p = (uint8_t *) getauxval(AT_RANDOM);

	if (p) {

		/*

		 * We get 16 bytes from getauxval.  By calling rand(),

		 * a totally insecure PRNG, but one that will

		 * deterministically have a different value when called

		 * twice, we ensure that if two talloc-like libraries

		 * are somehow loaded in the same address space, that

		 * because we choose different bytes, we will keep the

		 * protection against collision of multiple talloc

		 * libs.

		 *

		 * This protection is important because the effects of

		 * passing a talloc pointer from one to the other may

		 * be very hard to determine.

		 */

		int offset = rand() % (16 - sizeof(random_value));

		memcpy(&random_value, p + offset, sizeof(random_value));

	} else

#endif

	{

		/*

		 * Otherwise, hope the location we are loaded in

		 * memory is randomised by someone else

		 */

		random_value = ((uintptr_t)talloc_lib_init & 0xFFFFFFFF);

	}

	talloc_magic = random_value & ~TALLOC_FLAG_MASK;

}

#else

#warning "No __attribute__((constructor)) support found on this platform, additional talloc security measures not available"

#endif

static void talloc_lib_atexit(void)

{

	TALLOC_FREE(autofree_context);

	if (talloc_total_size(null_context) == 0) {

		return;

	}

	if (talloc_report_null_full) {

		talloc_report_full(null_context, stderr);

	} else if (talloc_report_null) {

		talloc_report(null_context, stderr);

	}

}

static void talloc_setup_atexit(void)

{

	static bool done;

	if (done) {

		return;

	}

	atexit(talloc_lib_atexit);

	done = true;

}

static void talloc_log(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);

static void talloc_log(const char *fmt, ...)

{

	va_list ap;

	char *message;

	if (!talloc_log_fn) {

		return;

	}

	va_start(ap, fmt);

	message = talloc_vasprintf(NULL, fmt, ap);

	va_end(ap);

	talloc_log_fn(message);

	talloc_free(message);

}

static void talloc_log_stderr(const char *message)

{

	fprintf(stderr, "%s", message);

}

_PUBLIC_ void talloc_set_log_stderr(void)

{

	talloc_set_log_fn(talloc_log_stderr);

}

static void (*talloc_abort_fn)(const char *reason);

_PUBLIC_ void talloc_set_abort_fn(void (*abort_fn)(const char *reason))

{

	talloc_abort_fn = abort_fn;

}

static void talloc_abort(const char *reason)

{

	talloc_log("%s\n", reason);

	if (!talloc_abort_fn) {

		TALLOC_ABORT(reason);

	}

	talloc_abort_fn(reason);

}

static void talloc_abort_access_after_free(void)

{

	talloc_abort("Bad talloc magic value - access after free");

}

static void talloc_abort_unknown_value(void)

{

	talloc_abort("Bad talloc magic value - unknown value");

}

/* panic if we get a bad magic value */

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 (unlikely((tc->flags & (TALLOC_FLAG_FREE | ~TALLOC_FLAG_MASK)) != talloc_magic)) {

		if ((tc->flags & (TALLOC_FLAG_FREE | ~TALLOC_FLAG_MASK))

		    == (TALLOC_MAGIC_NON_RANDOM | TALLOC_FLAG_FREE)) {

			talloc_log("talloc: access after free error - first free may be at %s\n", tc->name);

			talloc_abort_access_after_free();

			return NULL;

		}

		talloc_abort_unknown_value();

		return NULL;

	}

	return tc;

}

/* hook into the front of the list */

#define _TLIST_ADD(list, p) \

do { \

        if (!(list)) { \

		(list) = (p); \

		(p)->next = (p)->prev = NULL; \

	} else { \

		(list)->prev = (p); \

		(p)->next = (list); \

		(p)->prev = NULL; \

		(list) = (p); \

	}\

} while (0)

/* remove an element from a list - element doesn't have to be in list. */

#define _TLIST_REMOVE(list, p) \

do { \

	if ((p) == (list)) { \

		(list) = (p)->next; \

		if (list) (list)->prev = NULL; \

	} else { \

		if ((p)->prev) (p)->prev->next = (p)->next; \

		if ((p)->next) (p)->next->prev = (p)->prev; \

	} \

	if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \

} while (0)

/*

  return the parent chunk of a pointer

*/

static inline struct talloc_chunk *talloc_parent_chunk(const void *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;

}

_PUBLIC_ void *talloc_parent(const void *ptr)

{

	struct talloc_chunk *tc = talloc_parent_chunk(ptr);

	return tc? TC_PTR_FROM_CHUNK(tc) : NULL;

}

/*

  find parents name

*/

_PUBLIC_ const char *talloc_parent_name(const void *ptr)

{

	struct talloc_chunk *tc = talloc_parent_chunk(ptr);

	return tc? tc->name : NULL;

}

/*

  A pool carries an in-pool object count count in the first 16 bytes.

  bytes. This is done to support talloc_steal() to a parent outside of the

  pool. The count includes the pool itself, so a talloc_free() on a pool will

  only destroy the pool if the count has dropped to zero. A talloc_free() of a

  pool member will reduce the count, and eventually also call free(3) on the

  pool memory.

  The object count is not put into "struct talloc_chunk" because it is only

  relevant for talloc pools and the alignment to 16 bytes would increase the

  memory footprint of each talloc chunk by those 16 bytes.

*/

struct talloc_pool_hdr {

	void *end;

	unsigned int object_count;

	size_t poolsize;

};

union talloc_pool_hdr_cast_u {

	uint8_t *ptr;

	struct talloc_pool_hdr *hdr;

};

#define TP_HDR_SIZE TC_ALIGN16(sizeof(struct talloc_pool_hdr))

static inline struct talloc_pool_hdr *talloc_pool_from_chunk(struct talloc_chunk *c)

{

	union talloc_chunk_cast_u tcc = { .chunk = c };

	union talloc_pool_hdr_cast_u tphc = { tcc.ptr - TP_HDR_SIZE };

	return tphc.hdr;

}

static inline struct talloc_chunk *talloc_chunk_from_pool(struct talloc_pool_hdr *h)

{

	union talloc_pool_hdr_cast_u tphc = { .hdr = h };

	union talloc_chunk_cast_u tcc = { .ptr = tphc.ptr + TP_HDR_SIZE };

	return tcc.chunk;

}

static inline void *tc_pool_end(struct talloc_pool_hdr *pool_hdr)

{

	struct talloc_chunk *tc = talloc_chunk_from_pool(pool_hdr);

	return (char *)tc + TC_HDR_SIZE + pool_hdr->poolsize;

}

static inline size_t tc_pool_space_left(struct talloc_pool_hdr *pool_hdr)

{

	return (char *)tc_pool_end(pool_hdr) - (char *)pool_hdr->end;

}

/* If tc is inside a pool, this gives the next neighbour. */

static inline void *tc_next_chunk(struct talloc_chunk *tc)

{

	return (char *)tc + TC_ALIGN16(TC_HDR_SIZE + tc->size);

}

static inline void *tc_pool_first_chunk(struct talloc_pool_hdr *pool_hdr)

{

	struct talloc_chunk *tc = talloc_chunk_from_pool(pool_hdr);

	return tc_next_chunk(tc);

}

/* Mark the whole remaining pool as not accessable */

static inline void tc_invalidate_pool(struct talloc_pool_hdr *pool_hdr)

{

	size_t flen = tc_pool_space_left(pool_hdr);

	if (unlikely(talloc_fill.enabled)) {

		memset(pool_hdr->end, talloc_fill.fill_value, flen);

	}

#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)

	VALGRIND_MAKE_MEM_NOACCESS(pool_hdr->end, flen);

#endif

}

/*

  Allocate from a pool

*/

static inline struct talloc_chunk *tc_alloc_pool(struct talloc_chunk *parent,

						     size_t size, size_t prefix_len)

{

	struct talloc_pool_hdr *pool_hdr = NULL;

	union talloc_chunk_cast_u tcc;

	size_t space_left;

	struct talloc_chunk *result;

	size_t chunk_size;

	if (parent == NULL) {

		return NULL;

	}

	if (parent->flags & TALLOC_FLAG_POOL) {

		pool_hdr = talloc_pool_from_chunk(parent);

	}

	else if (parent->flags & TALLOC_FLAG_POOLMEM) {

		pool_hdr = parent->pool;

	}

	if (pool_hdr == NULL) {

		return NULL;

	}

	space_left = tc_pool_space_left(pool_hdr);

	/*

	 * Align size to 16 bytes

	 */

	chunk_size = TC_ALIGN16(size + prefix_len);

	if (space_left < chunk_size) {

		return NULL;

	}

	tcc = (union talloc_chunk_cast_u) {

		.ptr = ((uint8_t *)pool_hdr->end) + prefix_len

	};

	result = tcc.chunk;

#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)

	VALGRIND_MAKE_MEM_UNDEFINED(pool_hdr->end, chunk_size);

#endif

	pool_hdr->end = (void *)((char *)pool_hdr->end + chunk_size);

	result->flags = talloc_magic | TALLOC_FLAG_POOLMEM;

	result->pool = pool_hdr;

	pool_hdr->object_count++;

	return result;

}

/*

   Allocate a bit of memory as a child of an existing pointer

*/

static inline void *__talloc_with_prefix(const void *context,

					size_t size,

					size_t prefix_len,

					struct talloc_chunk **tc_ret)

{

	struct talloc_chunk *tc = NULL;

	struct talloc_memlimit *limit = NULL;

	size_t total_len = TC_HDR_SIZE + size + prefix_len;

	struct talloc_chunk *parent = NULL;

	if (unlikely(context == NULL)) {

		context = null_context;

	}

	if (unlikely(size >= MAX_TALLOC_SIZE)) {

		return NULL;

	}

	if (unlikely(total_len < TC_HDR_SIZE)) {

		return NULL;

	}

	if (likely(context != NULL)) {

		parent = talloc_chunk_from_ptr(context);

		if (parent->limit != NULL) {

			limit = parent->limit;

		}

		tc = tc_alloc_pool(parent, TC_HDR_SIZE+size, prefix_len);

	}

	if (tc == NULL) {

		uint8_t *ptr = NULL;

		union talloc_chunk_cast_u tcc;

		/*

		 * Only do the memlimit check/update on actual allocation.

		 */

		if (!talloc_memlimit_check(limit, total_len)) {

			errno = ENOMEM;

			return NULL;

		}

		ptr = malloc(total_len);

		if (unlikely(ptr == NULL)) {

			return NULL;

		}

		tcc = (union talloc_chunk_cast_u) { .ptr = ptr + prefix_len };

		tc = tcc.chunk;

		tc->flags = talloc_magic;

		tc->pool  = NULL;

		talloc_memlimit_grow(limit, total_len);

	}

	tc->limit = limit;

	tc->size = size;

	tc->destructor = NULL;

	tc->child = NULL;

	tc->name = NULL;

	tc->refs = NULL;

	if (likely(context != NULL)) {

		if (parent->child) {

			parent->child->parent = NULL;

			tc->next = parent->child;

			tc->next->prev = tc;

		} else {

			tc->next = NULL;

		}

		tc->parent = parent;

		tc->prev = NULL;

		parent->child = tc;

	} else {

		tc->next = tc->prev = tc->parent = NULL;

	}

	*tc_ret = tc;

	return TC_PTR_FROM_CHUNK(tc);

}

static inline void *__talloc(const void *context,

			size_t size,

			struct talloc_chunk **tc)

{

	return __talloc_with_prefix(context, size, 0, tc);

}

/*

 * Create a talloc pool

 */

static inline void *_talloc_pool(const void *context, size_t size)

{

	struct talloc_chunk *tc;

	struct talloc_pool_hdr *pool_hdr;

	void *result;

	result = __talloc_with_prefix(context, size, TP_HDR_SIZE, &tc);

	if (unlikely(result == NULL)) {

		return NULL;

	}

	pool_hdr = talloc_pool_from_chunk(tc);

	tc->flags |= TALLOC_FLAG_POOL;

	tc->size = 0;

	pool_hdr->object_count = 1;

	pool_hdr->end = result;

	pool_hdr->poolsize = size;

	tc_invalidate_pool(pool_hdr);

	return result;

}

_PUBLIC_ void *talloc_pool(const void *context, size_t size)

{

	return _talloc_pool(context, size);

}

/*

 * Create a talloc pool correctly sized for a basic size plus

 * a number of subobjects whose total size is given. Essentially

 * a custom allocator for talloc to reduce fragmentation.

 */

_PUBLIC_ void *_talloc_pooled_object(const void *ctx,

				     size_t type_size,

				     const char *type_name,

				     unsigned num_subobjects,

				     size_t total_subobjects_size)

{

	size_t poolsize, subobjects_slack, tmp;

	struct talloc_chunk *tc;

	struct talloc_pool_hdr *pool_hdr;

	void *ret;

	poolsize = type_size + total_subobjects_size;