#include <pthread.h>
#include "asterisk/utils.h"
#include "asterisk/inline_api.h"
Include dependency graph for threadstorage.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Data Structures | |
struct | ast_threadstorage |
data for a thread locally stored variable More... | |
Defines | |
#define | ast_dynamic_str_thread_append_va(buf, max_len, ts, fmt, ap) |
Append to a thread local dynamic string using a va_list. | |
#define | ast_dynamic_str_thread_set_va(buf, max_len, ts, fmt, ap) |
Set a thread locally stored dynamic string from a va_list. | |
#define | AST_THREADSTORAGE(name, name_init) AST_THREADSTORAGE_CUSTOM(name, name_init, ast_free) |
Define a thread storage variable. | |
#define | AST_THREADSTORAGE_CUSTOM(name, name_init, cleanup) |
#define | THREADSTORAGE_ONCE_INIT PTHREAD_ONCE_INIT |
Functions | |
ast_dynamic_str_thread_append (struct ast_dynamic_str **buf, size_t max_len, struct ast_threadstorage *ts, const char *fmt,...) | |
int | ast_dynamic_str_thread_build_va (struct ast_dynamic_str **buf, size_t max_len, struct ast_threadstorage *ts, int append, const char *fmt, va_list ap) |
Core functionality of ast_dynamic_str_thread_(set|append)_va. | |
AST_INLINE_API (int __attribute__((format(printf, 4, 5))) ast_dynamic_str_thread_set(struct ast_dynamic_str **buf, size_t max_len, struct ast_threadstorage *ts, const char *fmt,...),{int res;va_list ap;va_start(ap, fmt);res=ast_dynamic_str_thread_set_va(buf, max_len, ts, fmt, ap);va_end(ap);return res;}) AST_INLINE_API(int __attribute__((format(printf | |
Set a thread locally stored dynamic string using variable argumentsAppend to a thread local dynamic string. | |
AST_INLINE_API (struct ast_dynamic_str *attribute_malloc ast_dynamic_str_create(size_t init_len),{struct ast_dynamic_str *buf;if(!(buf=ast_calloc(1, sizeof(*buf)+init_len))) return NULL;buf->len=init_len;return buf;}) AST_INLINE_API(struct ast_dynamic_str *ast_dynamic_str_thread_get(struct ast_threadstorage *ts | |
Create a dynamic length stringRetrieve a thread locally stored dynamic string. | |
AST_INLINE_API (void *ast_threadstorage_get(struct ast_threadstorage *ts, size_t init_size),{void *buf;pthread_once(&ts->once, ts->key_init);if(!(buf=pthread_getspecific(ts->key))){if(!(buf=ast_calloc(1, init_size))) return NULL;pthread_setspecific(ts->key, buf);}return buf;}) struct ast_dynamic_str | |
Retrieve thread storageA dynamic length string. | |
Variables | |
size_t | init_len |
Definition in file threadstorage.h.
#define ast_dynamic_str_thread_append_va | ( | buf, | |||
max_len, | |||||
ts, | |||||
fmt, | |||||
ap | ) |
Append to a thread local dynamic string using a va_list.
The arguments, return values, and usage of this are the same as those for ast_dynamic_str_thread_set_va(). However, instead of setting a new value for the string, this will append to the current value.
Definition at line 366 of file threadstorage.h.
Referenced by manager_event().
#define ast_dynamic_str_thread_set_va | ( | buf, | |||
max_len, | |||||
ts, | |||||
fmt, | |||||
ap | ) |
Set a thread locally stored dynamic string from a va_list.
AST_THREADSTORAGE(my_str, my_str_init); #define MY_STR_INIT_SIZE 128 ... void my_func(const char *fmt, ...) { struct ast_dynamic_str *buf; va_list ap; if (!(buf = ast_dynamic_str_thread_get(&my_str, MY_STR_INIT_SIZE))) return; ... va_start(fmt, ap); ast_dynamic_str_thread_set_va(&buf, 0, &my_str, fmt, ap); va_end(ap); printf("This is the string we just built: %s\n", buf->str); ... }
Definition at line 348 of file threadstorage.h.
Referenced by ast_cli(), ast_log(), ast_verbose(), and astman_append().
Define a thread storage variable.
Example usage:
AST_THREADSTORAGE(my_buf, my_buf_init);
Definition at line 92 of file threadstorage.h.
#define AST_THREADSTORAGE_CUSTOM | ( | name, | |||
name_init, | |||||
cleanup | ) |
Definition at line 96 of file threadstorage.h.
#define THREADSTORAGE_ONCE_INIT PTHREAD_ONCE_INIT |
Definition at line 68 of file threadstorage.h.
ast_dynamic_str_thread_append | ( | struct ast_dynamic_str ** | buf, | |
size_t | max_len, | |||
struct ast_threadstorage * | ts, | |||
const char * | fmt, | |||
... | ||||
) |
Referenced by manager_event().
int ast_dynamic_str_thread_build_va | ( | struct ast_dynamic_str ** | buf, | |
size_t | max_len, | |||
struct ast_threadstorage * | ts, | |||
int | append, | |||
const char * | fmt, | |||
va_list | ap | |||
) |
Core functionality of ast_dynamic_str_thread_(set|append)_va.
The arguments to this function are the same as those described for ast_dynamic_str_thread_set_va except for an addition argument, append. If append is non-zero, this will append to the current string instead of writing over it.
In the case that this function is called and the buffer was not large enough to hold the result, the partial write will be truncated, and the result AST_DYNSTR_BUILD_RETRY will be returned to indicate that the buffer size was increased, and the function should be called a second time.
A return of AST_DYNSTR_BUILD_FAILED indicates a memory allocation error.
A return value greater than or equal to zero indicates the number of characters that have been written, not including the terminating ''. In the append case, this only includes the number of characters appended.
Definition at line 1221 of file utils.c.
References ast_realloc, ast_threadstorage::key, and offset.
01223 { 01224 int res; 01225 int offset = (append && (*buf)->len) ? strlen((*buf)->str) : 0; 01226 #if defined(DEBUG_THREADLOCALS) 01227 struct ast_dynamic_str *old_buf = *buf; 01228 #endif /* defined(DEBUG_THREADLOCALS) */ 01229 01230 res = vsnprintf((*buf)->str + offset, (*buf)->len - offset, fmt, ap); 01231 01232 /* Check to see if there was not enough space in the string buffer to prepare 01233 * the string. Also, if a maximum length is present, make sure the current 01234 * length is less than the maximum before increasing the size. */ 01235 if ((res + offset + 1) > (*buf)->len && (max_len ? ((*buf)->len < max_len) : 1)) { 01236 /* Set the new size of the string buffer to be the size needed 01237 * to hold the resulting string (res) plus one byte for the 01238 * terminating '\0'. If this size is greater than the max, set 01239 * the new length to be the maximum allowed. */ 01240 if (max_len) 01241 (*buf)->len = ((res + offset + 1) < max_len) ? (res + offset + 1) : max_len; 01242 else 01243 (*buf)->len = res + offset + 1; 01244 01245 if (!(*buf = ast_realloc(*buf, (*buf)->len + sizeof(*(*buf))))) 01246 return AST_DYNSTR_BUILD_FAILED; 01247 01248 if (append) 01249 (*buf)->str[offset] = '\0'; 01250 01251 if (ts) { 01252 pthread_setspecific(ts->key, *buf); 01253 #if defined(DEBUG_THREADLOCALS) 01254 __ast_threadstorage_object_replace(old_buf, *buf, (*buf)->len + sizeof(*(*buf))); 01255 #endif /* defined(DEBUG_THREADLOCALS) */ 01256 } 01257 01258 /* va_end() and va_start() must be done before calling 01259 * vsnprintf() again. */ 01260 return AST_DYNSTR_BUILD_RETRY; 01261 } 01262 01263 return res; 01264 }
AST_INLINE_API | ( | int | __attribute__((format(printf, 4, 5))) ast_dynamic_str_thread_set(struct ast_dynamic_str **buf, size_t max_len,struct ast_threadstorage *ts, const char *fmt,...) | ) |
Set a thread locally stored dynamic string using variable argumentsAppend to a thread local dynamic string.
The arguments, return values, and usage of this function are the same as ast_dynamic_str_thread_set(). However, instead of setting a new value for the string, this function appends to the current value.
AST_INLINE_API | ( | struct ast_dynamic_str *attribute_malloc | ast_dynamic_str_create(size_t init_len) | ) |
Create a dynamic length stringRetrieve a thread locally stored dynamic string.
AST_THREADSTORAGE(my_str, my_str_init); #define MY_STR_INIT_SIZE 128 ... void my_func(const char *fmt, ...) { struct ast_dynamic_str *buf; if (!(buf = ast_dynamic_str_thread_get(&my_str, MY_STR_INIT_SIZE))) return; ... }
AST_INLINE_API | ( | void * | ast_threadstorage_get(struct ast_threadstorage *ts, size_t init_size) | ) |
Retrieve thread storageA dynamic length string.
Definition at line 155 of file threadstorage.h.
References ast_calloc.
00157 { 00158 void *buf; 00159 00160 pthread_once(&ts->once, ts->key_init); 00161 if (!(buf = pthread_getspecific(ts->key))) { 00162 if (!(buf = ast_calloc(1, init_size))) 00163 return NULL; 00164 pthread_setspecific(ts->key, buf); 00165 } 00166 00167 return buf; 00168 } 00169 ) 00170 #else /* defined(DEBUG_THREADLOCALS) */ 00171 AST_INLINE_API( 00172 void *__ast_threadstorage_get(struct ast_threadstorage *ts, size_t init_size, const char *file, const char *function, unsigned int line), 00173 { 00174 void *buf; 00175 00176 pthread_once(&ts->once, ts->key_init); 00177 if (!(buf = pthread_getspecific(ts->key))) { 00178 if (!(buf = ast_calloc(1, init_size))) 00179 return NULL; 00180 pthread_setspecific(ts->key, buf); 00181 __ast_threadstorage_object_add(buf, init_size, file, function, line); 00182 } 00183 00184 return buf; 00185 } 00186 ) 00187 00188 #define ast_threadstorage_get(ts, init_size) __ast_threadstorage_get(ts, init_size, __FILE__, __PRETTY_FUNCTION__, __LINE__) 00189 #endif /* defined(DEBUG_THREADLOCALS) */ 00190 00191 /*! 00192 * \brief A dynamic length string 00193 */ 00194 struct ast_dynamic_str { 00195 /* The current maximum length of the string */ 00196 size_t len; 00197 /* The string buffer */ 00198 char str[0]; 00199 };
size_t init_len |
Definition at line 260 of file threadstorage.h.