stringfields.c File Reference

String fields. More...

#include "asterisk.h"
#include "asterisk/stringfields.h"
#include "asterisk/utils.h"

Include dependency graph for stringfields.c:

Go to the source code of this file.

Macros
#define	ALLOCATOR_OVERHEAD   48

Functions
void *	__ast_calloc_with_stringfields (unsigned int num_structs, size_t struct_size, size_t field_mgr_offset, size_t field_mgr_pool_offset, size_t pool_size, const char *file, int lineno, const char *func)
ast_string_field	__ast_string_field_alloc_space (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t needed, const char *file, int lineno, const char *func)
int	__ast_string_field_free_memory (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, enum ast_stringfield_cleanup_type cleanup_type, const char *file, int lineno, const char *func)
	Internal cleanup function. More...
int	__ast_string_field_init (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, int needed, const char *file, int lineno, const char *func)
	Internal initialization function. More...
void	__ast_string_field_ptr_build (const char *file, int lineno, const char *func, struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format,...)
void	__ast_string_field_ptr_build_va (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format, va_list ap, const char *file, int lineno, const char *func)
int	__ast_string_field_ptr_grow (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t needed, const ast_string_field *ptr)
void	__ast_string_field_release_active (struct ast_string_field_pool *pool_head, const ast_string_field ptr)
int	__ast_string_fields_cmp (struct ast_string_field_vector *left, struct ast_string_field_vector *right)
int	__ast_string_fields_copy (struct ast_string_field_pool *copy_pool, struct ast_string_field_mgr *copy_mgr, struct ast_string_field_mgr *orig_mgr, const char *file, int lineno, const char *func)
static int	add_string_pool (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t size, const char *file, int lineno, const char *func)
	add a new block to the pool. We can only allocate from the topmost pool, so the fields in *mgr reflect the size of that only. More...
static size_t	optimal_alloc_size (size_t size)
static void	reset_field (const char **p)

Variables
ast_string_field	__ast_string_field_empty = __ast_string_field_empty_buffer.string
struct {
ast_string_field_allocation   allocation
char   string [1]
}	__ast_string_field_empty_buffer

Detailed Description

String fields.

Author

Kevin P. Fleming kpfle.nosp@m.ming.nosp@m.@digi.nosp@m.um.c.nosp@m.om

Definition in file stringfields.c.

Macro Definition Documentation

ALLOCATOR_OVERHEAD

#define ALLOCATOR_OVERHEAD   48

Definition at line 45 of file stringfields.c.

Referenced by optimal_alloc_size().

Function Documentation

__ast_calloc_with_stringfields()

void* __ast_calloc_with_stringfields	(	unsigned int	num_structs,
		size_t	struct_size,
		size_t	field_mgr_offset,
		size_t	field_mgr_pool_offset,
		size_t	pool_size,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 380 of file stringfields.c.

References __ast_calloc(), __ast_string_field_empty, allocation, ast_assert, ast_free, AST_VECTOR_APPEND, AST_VECTOR_INIT, ast_string_field_mgr::embedded_pool, NULL, optimal_alloc_size(), pool, ast_string_field_pool::size, and ast_string_field_mgr::string_fields.

{
 struct ast_string_field_mgr *mgr;
 struct ast_string_field_pool *pool;
 struct ast_string_field_pool **pool_head;
 size_t pool_size_needed = sizeof(*pool) + pool_size;
 size_t size_to_alloc = optimal_alloc_size(struct_size + pool_size_needed);
 void *allocation;
 const char **p;
 size_t initial_vector_size;

 ast_assert(num_structs == 1);

 allocation = __ast_calloc(num_structs, size_to_alloc, file, lineno, func);
 if (!allocation) {
 return NULL;
 }

 mgr = allocation + field_mgr_offset;

 pool = allocation + struct_size;
 pool_head = allocation + field_mgr_pool_offset;
 p = (const char **) pool_head + 1;
 initial_vector_size = ((size_t) (((char *)mgr) - ((char *)p))) / sizeof(*p);

 if (AST_VECTOR_INIT(&mgr->string_fields, initial_vector_size)) {
 ast_free(allocation);
 return NULL;
 }

 while ((struct ast_string_field_mgr *) p != mgr) {
 AST_VECTOR_APPEND(&mgr->string_fields, p);
 *p++ = __ast_string_field_empty;
 }

 mgr->embedded_pool = pool;
 *pool_head = pool;
 pool->size = size_to_alloc - struct_size - sizeof(*pool);

 return allocation;
}

__ast_string_field_alloc_space()

ast_string_field __ast_string_field_alloc_space	(	struct ast_string_field_mgr *	mgr,
		struct ast_string_field_pool **	pool_head,
		size_t	needed,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 202 of file stringfields.c.

References add_string_pool(), ast_alignof, ast_assert, ast_make_room_for, AST_STRING_FIELD_ALLOCATION, ast_string_field_mgr::last_alloc, NULL, and result.

Referenced by __ast_string_field_ptr_build_va().

{
 char *result = NULL;
 size_t space = (*pool_head)->size - (*pool_head)->used;
 size_t to_alloc;

 /* Make room for ast_string_field_allocation and make it a multiple of that. */
 to_alloc = ast_make_room_for(needed, ast_string_field_allocation);
 ast_assert(to_alloc % ast_alignof(ast_string_field_allocation) == 0);

 if (__builtin_expect(to_alloc > space, 0)) {
 size_t new_size = (*pool_head)->size;

 while (new_size < to_alloc) {
 new_size *= 2;
 }

 if (add_string_pool(mgr, pool_head, new_size, file, lineno, func)) {
 return NULL;
 }
 }

 /* pool->base is always aligned (gcc aligned attribute). We ensure that
 * to_alloc is also a multiple of ast_alignof(ast_string_field_allocation)
 * causing result to always be aligned as well; which in turn fixes that
 * AST_STRING_FIELD_ALLOCATION(result) is aligned. */
 result = (*pool_head)->base + (*pool_head)->used;
 (*pool_head)->used += to_alloc;
 (*pool_head)->active += needed;
 result += ast_alignof(ast_string_field_allocation);
 AST_STRING_FIELD_ALLOCATION(result) = needed;
 mgr->last_alloc = result;

 return result;
}

__ast_string_field_free_memory()

int __ast_string_field_free_memory	(	struct ast_string_field_mgr *	mgr,
		struct ast_string_field_pool **	pool_head,
		enum ast_stringfield_cleanup_type	cleanup_type,
		const char *	file,
		int	lineno,
		const char *	func
	)

Internal cleanup function.

Definition at line 103 of file stringfields.c.

References ast_string_field_pool::active, ast_free, ast_log, AST_STRINGFIELD_DESTROY, AST_STRINGFIELD_RESET, AST_VECTOR_CALLBACK_VOID, AST_VECTOR_FREE, ast_string_field_mgr::embedded_pool, LOG_WARNING, NULL, ast_string_field_pool::prev, reset_field(), ast_string_field_mgr::string_fields, and ast_string_field_pool::used.

Referenced by __ast_string_field_init().

{
 struct ast_string_field_pool *cur = NULL;
 struct ast_string_field_pool *preserve = NULL;

 /* reset all the fields regardless of cleanup type */
 AST_VECTOR_CALLBACK_VOID(&mgr->string_fields, reset_field);

 switch (cleanup_type) {
 case AST_STRINGFIELD_DESTROY:
 AST_VECTOR_FREE(&mgr->string_fields);

 if (mgr->embedded_pool) { /* ALWAYS preserve the embedded pool if there is one */
 preserve = mgr->embedded_pool;
 preserve->used = preserve->active = 0;
 }

 break;
 case AST_STRINGFIELD_RESET:
 /* Preserve the embedded pool if there is one, otherwise the last pool */
 if (mgr->embedded_pool) {
 preserve = mgr->embedded_pool;
 } else {
 if (*pool_head == NULL) {
 ast_log(LOG_WARNING, "trying to reset empty pool\n");
 return -1;
 }
 preserve = *pool_head;
 }
 preserve->used = preserve->active = 0;
 break;
 default:
 return -1;
 }

 cur = *pool_head;
 while (cur) {
 struct ast_string_field_pool *prev = cur->prev;

 if (cur != preserve) {
 ast_free(cur);
 }
 cur = prev;
 }

 *pool_head = preserve;
 if (preserve) {
 preserve->prev = NULL;
 }

 return 0;
}

__ast_string_field_init()

int __ast_string_field_init	(	struct ast_string_field_mgr *	mgr,
		struct ast_string_field_pool **	pool_head,
		int	needed,
		const char *	file,
		int	lineno,
		const char *	func
	)

Internal initialization function.

Definition at line 171 of file stringfields.c.

References __ast_string_field_empty, __ast_string_field_free_memory(), add_string_pool(), AST_VECTOR_APPEND, AST_VECTOR_FREE, AST_VECTOR_INIT, ast_string_field_mgr::embedded_pool, ast_string_field_mgr::last_alloc, NULL, and ast_string_field_mgr::string_fields.

{
 const char **p = (const char **) pool_head + 1;
 size_t initial_vector_size = ((size_t) (((char *)mgr) - ((char *)p))) / sizeof(*p);

 if (needed <= 0) {
 return __ast_string_field_free_memory(mgr, pool_head, needed, file, lineno, func);
 }

 mgr->last_alloc = NULL;

 if (AST_VECTOR_INIT(&mgr->string_fields, initial_vector_size)) {
 return -1;
 }

 while ((struct ast_string_field_mgr *) p != mgr) {
 AST_VECTOR_APPEND(&mgr->string_fields, p);
 *p++ = __ast_string_field_empty;
 }

 *pool_head = NULL;
 mgr->embedded_pool = NULL;
 if (add_string_pool(mgr, pool_head, needed, file, lineno, func)) {
 AST_VECTOR_FREE(&mgr->string_fields);
 return -1;
 }

 return 0;
}

__ast_string_field_ptr_build()

void __ast_string_field_ptr_build	(	const char *	file,
		int	lineno,
		const char *	func,
		struct ast_string_field_mgr *	mgr,
		struct ast_string_field_pool **	pool_head,
		ast_string_field *	ptr,
		const char *	format,
			...
	)

Definition at line 369 of file stringfields.c.

References __ast_string_field_ptr_build_va().

{
 va_list ap;

 va_start(ap, format);
 __ast_string_field_ptr_build_va(mgr, pool_head, ptr, format, ap, file, lineno, func);
 va_end(ap);
}

__ast_string_field_ptr_build_va()

void __ast_string_field_ptr_build_va	(	struct ast_string_field_mgr *	mgr,
		struct ast_string_field_pool **	pool_head,
		ast_string_field *	ptr,
		const char *	format,
		va_list	ap,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 286 of file stringfields.c.

References __ast_string_field_alloc_space(), __ast_string_field_empty, __ast_string_field_release_active(), ast_align_for, ast_alignof, ast_assert, ast_make_room_for, AST_STRING_FIELD_ALLOCATION, available(), grow(), and ast_string_field_mgr::last_alloc.

Referenced by __ast_string_field_ptr_build().

{
 size_t needed;
 size_t available;
 size_t space = (*pool_head)->size - (*pool_head)->used;
 int res;
 ssize_t grow;
 char *target;
 va_list ap2;

 /* if the field already has space allocated, try to reuse it;
 otherwise, try to use the empty space at the end of the current
 pool
 */
 if (*ptr != __ast_string_field_empty) {
 target = (char *) *ptr;
 available = AST_STRING_FIELD_ALLOCATION(*ptr);
 if (*ptr == mgr->last_alloc) {
 available += space;
 }
 } else {
 /* pool->used is always a multiple of ast_alignof(ast_string_field_allocation)
 * so we don't need to re-align anything here.
 */
 target = (*pool_head)->base + (*pool_head)->used + ast_alignof(ast_string_field_allocation);
 if (space > ast_alignof(ast_string_field_allocation)) {
 available = space - ast_alignof(ast_string_field_allocation);
 } else {
 available = 0;
 }
 }

 va_copy(ap2, ap);
 res = vsnprintf(target, available, format, ap2);
 va_end(ap2);

 if (res < 0) {
 /* Are we out of memory? */
 return;
 }
 if (res == 0) {
 __ast_string_field_release_active(*pool_head, *ptr);
 *ptr = __ast_string_field_empty;
 return;
 }
 needed = (size_t)res + 1; /* NUL byte */

 if (needed > available) {
 /* the allocation could not be satisfied using the field's current allocation
 (if it has one), or the space available in the pool (if it does not). allocate
 space for it, adding a new string pool if necessary.
 */
 target = (char *) __ast_string_field_alloc_space(mgr, pool_head, needed, file, lineno, func);
 if (!target) {
 return;
 }
 vsprintf(target, format, ap);
 va_end(ap); /* XXX va_end without va_start? */
 __ast_string_field_release_active(*pool_head, *ptr);
 *ptr = target;
 } else if (*ptr != target) {
 /* the allocation was satisfied using available space in the pool, but not
 using the space already allocated to the field
 */
 __ast_string_field_release_active(*pool_head, *ptr);
 mgr->last_alloc = *ptr = target;
 ast_assert(needed < (ast_string_field_allocation)-1);
 AST_STRING_FIELD_ALLOCATION(target) = (ast_string_field_allocation)needed;
 (*pool_head)->used += ast_make_room_for(needed, ast_string_field_allocation);
 (*pool_head)->active += needed;
 } else if ((grow = (needed - AST_STRING_FIELD_ALLOCATION(*ptr))) > 0) {
 /* the allocation was satisfied by using available space in the pool *and*
 the field was the last allocated field from the pool, so it grew
 */
 AST_STRING_FIELD_ALLOCATION(*ptr) += grow;
 (*pool_head)->used += ast_align_for(grow, ast_string_field_allocation);
 (*pool_head)->active += grow;
 }
}

__ast_string_field_ptr_grow()

int __ast_string_field_ptr_grow	(	struct ast_string_field_mgr *	mgr,
		struct ast_string_field_pool **	pool_head,
		size_t	needed,
		const ast_string_field *	ptr
	)

Definition at line 240 of file stringfields.c.

References AST_STRING_FIELD_ALLOCATION, grow(), and ast_string_field_mgr::last_alloc.

{
 ssize_t grow = needed - AST_STRING_FIELD_ALLOCATION(*ptr);
 size_t space = (*pool_head)->size - (*pool_head)->used;

 if (*ptr != mgr->last_alloc) {
 return 1;
 }

 if (space < grow) {
 return 1;
 }

 (*pool_head)->used += grow;
 (*pool_head)->active += grow;
 AST_STRING_FIELD_ALLOCATION(*ptr) += grow;

 return 0;
}

__ast_string_field_release_active()

void __ast_string_field_release_active	(	struct ast_string_field_pool *	pool_head,
		const ast_string_field	ptr
	)

Definition at line 261 of file stringfields.c.

References __ast_string_field_empty, ast_string_field_pool::active, ast_free, AST_STRING_FIELD_ALLOCATION, NULL, pool, and ast_string_field_pool::prev.

Referenced by __ast_string_field_ptr_build_va(), and __ast_string_fields_copy().

{
 struct ast_string_field_pool *pool, *prev;

 if (ptr == __ast_string_field_empty) {
 return;
 }

 for (pool = pool_head, prev = NULL; pool; prev = pool, pool = pool->prev) {
 if ((ptr >= pool->base) && (ptr <= (pool->base + pool->size))) {
 pool->active -= AST_STRING_FIELD_ALLOCATION(ptr);
 if (pool->active == 0) {
 if (prev) {
 prev->prev = pool->prev;
 ast_free(pool);
 } else {
 pool->used = 0;
 }
 }
 break;
 }
 }
}

__ast_string_fields_cmp()

int __ast_string_fields_cmp	(	struct ast_string_field_vector *	left,
		struct ast_string_field_vector *	right
	)

Definition at line 424 of file stringfields.c.

References ast_assert, AST_VECTOR_GET, and AST_VECTOR_SIZE.

{
 int i;
 int res = 0;

 ast_assert(AST_VECTOR_SIZE(left) == AST_VECTOR_SIZE(right));

 for (i = 0; i < AST_VECTOR_SIZE(left); i++) {
 if ((res = strcmp(*AST_VECTOR_GET(left, i), *AST_VECTOR_GET(right, i)))) {
 return res;
 }
 }

 return res;
}

__ast_string_fields_copy()

int __ast_string_fields_copy	(	struct ast_string_field_pool *	copy_pool,
		struct ast_string_field_mgr *	copy_mgr,
		struct ast_string_field_mgr *	orig_mgr,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 441 of file stringfields.c.

References __ast_string_field_empty, __ast_string_field_ptr_set_by_fields, __ast_string_field_release_active(), ast_assert, AST_VECTOR_GET, AST_VECTOR_SIZE, and ast_string_field_mgr::string_fields.

{
 int i;
 struct ast_string_field_vector *dest = &(copy_mgr->string_fields);
 struct ast_string_field_vector *src = &(orig_mgr->string_fields);

 ast_assert(AST_VECTOR_SIZE(dest) == AST_VECTOR_SIZE(src));

 for (i = 0; i < AST_VECTOR_SIZE(dest); i++) {
 __ast_string_field_release_active(copy_pool, *AST_VECTOR_GET(dest, i));
 *AST_VECTOR_GET(dest, i) = __ast_string_field_empty;
 }

 for (i = 0; i < AST_VECTOR_SIZE(dest); i++) {
 if (__ast_string_field_ptr_set_by_fields(copy_pool, *copy_mgr, AST_VECTOR_GET(dest, i),
 *AST_VECTOR_GET(src, i), file, lineno, func)) {
 return -1;
 }
 }

 return 0;
}

add_string_pool()

static int add_string_pool ( struct ast_string_field_mgr *  mgr, struct ast_string_field_pool **  pool_head, size_t  size, const char *  file, int  lineno, const char *  func  )

static

add a new block to the pool. We can only allocate from the topmost pool, so the fields in *mgr reflect the size of that only.

Definition at line 62 of file stringfields.c.

References __ast_calloc(), ast_string_field_mgr::last_alloc, NULL, optimal_alloc_size(), pool, ast_string_field_pool::prev, and ast_string_field_pool::size.

Referenced by __ast_string_field_alloc_space(), and __ast_string_field_init().

{
 struct ast_string_field_pool *pool;
 size_t alloc_size = optimal_alloc_size(sizeof(*pool) + size);

 pool = __ast_calloc(1, alloc_size, file, lineno, func);
 if (!pool) {
 return -1;
 }

 pool->prev = *pool_head;
 pool->size = alloc_size - sizeof(*pool);
 *pool_head = pool;
 mgr->last_alloc = NULL;

 return 0;
}

optimal_alloc_size()

static size_t optimal_alloc_size ( size_t  size )

static

Definition at line 47 of file stringfields.c.

References ALLOCATOR_OVERHEAD.

Referenced by __ast_calloc_with_stringfields(), and add_string_pool().

{
 unsigned int count;

 size += ALLOCATOR_OVERHEAD;

 for (count = 1; size; size >>= 1, count++);

 return (1 << count) - ALLOCATOR_OVERHEAD;
}

reset_field()

static void reset_field ( const char **  p )

static

Definition at line 81 of file stringfields.c.

References __ast_string_field_empty.

Referenced by __ast_string_field_free_memory().

{
 *p = __ast_string_field_empty;
}

Variable Documentation

__ast_string_field_empty

ast_string_field __ast_string_field_empty = __ast_string_field_empty_buffer.string

Definition at line 43 of file stringfields.c.

Referenced by __ast_calloc_with_stringfields(), __ast_string_field_init(), __ast_string_field_ptr_build_va(), __ast_string_field_release_active(), __ast_string_fields_copy(), AST_TEST_DEFINE(), and reset_field().

__ast_string_field_empty_buffer

const { ... } __ast_string_field_empty_buffer

allocation

ast_string_field_allocation allocation

Definition at line 39 of file stringfields.c.

Referenced by __ast_calloc_with_stringfields().

string

char string[1]

Definition at line 40 of file stringfields.c.