String fields. More...

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

Include dependency graph for stringfields.c:

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.

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.

{
    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;
}

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

◆ __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.

{
    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;
}

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

Referenced by __ast_string_field_ptr_build_va().

◆ __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.

{
    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;
}

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().

◆ __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.

{
    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;
}

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, make_ari_stubs::file, ast_string_field_mgr::last_alloc, NULL, and ast_string_field_mgr::string_fields.

◆ __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.

{
    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);
}

References __ast_string_field_ptr_build_va(), and make_ari_stubs::file.

◆ __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.

{
    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;
    }
}

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(), make_ari_stubs::file, grow(), and ast_string_field_mgr::last_alloc.

Referenced by __ast_string_field_ptr_build().

◆ __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.

{
    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;
}

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

◆ __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.

{
    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;
        }
    }
}

References __ast_string_field_empty, ast_string_field_pool::active, ast_free, AST_STRING_FIELD_ALLOCATION, ast_string_field_pool::base, NULL, ast_string_field_pool::prev, ast_string_field_pool::size, and ast_string_field_pool::used.

Referenced by __ast_string_field_ptr_build_va(), and __ast_string_fields_copy().

◆ __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.

{
    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;
}

References ast_assert, AST_VECTOR_GET, and AST_VECTOR_SIZE.

◆ __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.

{
    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;
}

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, make_ari_stubs::file, and ast_string_field_mgr::string_fields.

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

{
    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;
}

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

Referenced by __ast_string_field_alloc_space(), and __ast_string_field_init().

◆ optimal_alloc_size()

static size_t optimal_alloc_size ( size_t size )

static

Definition at line 47 of file stringfields.c.

{
    unsigned int count;
 
    size += ALLOCATOR_OVERHEAD;
 
    for (count = 1; size; size >>= 1, count++);
 
    return (1 << count) - ALLOCATOR_OVERHEAD;
}