void (*key_init)(void);
};
+
+#if defined(DEBUG_THREADLOCALS)
+void __ast_threadstorage_object_add(void *key, size_t len, const char *file, const char *function, unsigned int line);
+void __ast_threadstorage_object_remove(void *key);
+void __ast_threadstorage_object_replace(void *key_old, void *key_new, size_t len);
+#endif /* defined(DEBUG_THREADLOCALS) */
+
/*!
* \brief Define a thread storage variable
*
#define AST_THREADSTORAGE(name, name_init) \
AST_THREADSTORAGE_CUSTOM(name, name_init, ast_free)
+#if !defined(DEBUG_THREADLOCALS)
#define AST_THREADSTORAGE_CUSTOM(name, name_init, cleanup) \
static void name_init(void); \
static struct ast_threadstorage name = { \
{ \
pthread_key_create(&(name).key, cleanup); \
}
+#else /* defined(DEBUG_THREADLOCALS) */
+#define AST_THREADSTORAGE_CUSTOM(name, name_init, cleanup) \
+static void name_init(void); \
+static struct ast_threadstorage name = { \
+ .once = PTHREAD_ONCE_INIT, \
+ .key_init = name_init, \
+}; \
+static void __cleanup_##name(void *data) \
+{ \
+ __ast_threadstorage_object_remove(data); \
+ cleanup(data); \
+} \
+static void name_init(void) \
+{ \
+ pthread_key_create(&(name).key, __cleanup_##name); \
+}
+#endif /* defined(DEBUG_THREADLOCALS) */
/*!
* \brief Retrieve thread storage
* }
* \endcode
*/
+#if !defined(DEBUG_THREADLOCALS)
AST_INLINE_API(
void *ast_threadstorage_get(struct ast_threadstorage *ts, size_t init_size),
{
return buf;
}
)
+#else /* defined(DEBUG_THREADLOCALS) */
+AST_INLINE_API(
+void *__ast_threadstorage_get(struct ast_threadstorage *ts, size_t init_size, const char *file, const char *function, unsigned int line),
+{
+ 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);
+ __ast_threadstorage_object_add(buf, init_size, file, function, line);
+ }
+
+ return buf;
+}
+)
+
+#define ast_threadstorage_get(ts, init_size) __ast_threadstorage_get(ts, init_size, __FILE__, __PRETTY_FUNCTION__, __LINE__)
+#endif /* defined(DEBUG_THREADLOCALS) */
/*!
* \brief A dynamic length string
* }
* \endcode
*/
+#if !defined(DEBUG_THREADLOCALS)
AST_INLINE_API(
struct ast_dynamic_str *ast_dynamic_str_thread_get(struct ast_threadstorage *ts,
size_t init_len),
return buf;
}
)
+#else /* defined(DEBUG_THREADLOCALS) */
+AST_INLINE_API(
+struct ast_dynamic_str *__ast_dynamic_str_thread_get(struct ast_threadstorage *ts,
+ size_t init_len, const char *file, const char *function, unsigned int line),
+{
+ struct ast_dynamic_str *buf;
+
+ if (!(buf = __ast_threadstorage_get(ts, sizeof(*buf) + init_len, file, function, line)))
+ return NULL;
+
+ if (!buf->len)
+ buf->len = init_len;
+
+ return buf;
+}
+)
+
+#define ast_dynamic_str_thread_get(ts, init_len) __ast_dynamic_str_thread_get(ts, init_len, __FILE__, __PRETTY_FUNCTION__, __LINE__)
+#endif /* defined(DEBUG_THREADLOCALS) */
/*!
* \brief Error codes from ast_dynamic_str_thread_build_va()
--- /dev/null
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 1999 - 2005, Digium, Inc.
+ *
+ * Kevin P. Fleming <kpfleming@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief Debugging support for thread-local-storage objects
+ *
+ * \author Kevin P. Fleming <kpfleming@digium.com>
+ */
+
+#include "asterisk.h"
+
+#if defined(DEBUG_THREADLOCALS)
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "asterisk/logger.h"
+#include "asterisk/strings.h"
+#include "asterisk/utils.h"
+#include "asterisk/threadstorage.h"
+#include "asterisk/linkedlists.h"
+#include "asterisk/cli.h"
+
+struct tls_object {
+ void *key;
+ size_t size;
+ const char *file;
+ const char *function;
+ unsigned int line;
+ pthread_t thread;
+ AST_LIST_ENTRY(tls_object) entry;
+};
+
+static AST_LIST_HEAD_STATIC(tls_objects, tls_object);
+
+void __ast_threadstorage_object_add(void *key, size_t len, const char *file, const char *function, unsigned int line)
+{
+ struct tls_object *to;
+
+ if (!(to = ast_calloc(sizeof(*to), 1)))
+ return;
+
+ to->key = key;
+ to->size = len;
+ to->file = file;
+ to->function = function;
+ to->line = line;
+ to->thread = pthread_self();
+
+ AST_LIST_LOCK(&tls_objects);
+ AST_LIST_INSERT_TAIL(&tls_objects, to, entry);
+ AST_LIST_UNLOCK(&tls_objects);
+}
+
+void __ast_threadstorage_object_remove(void *key)
+{
+ struct tls_object *to;
+
+ AST_LIST_LOCK(&tls_objects);
+ AST_LIST_TRAVERSE_SAFE_BEGIN(&tls_objects, to, entry) {
+ if (to->key == key) {
+ AST_LIST_REMOVE_CURRENT(&tls_objects, entry);
+ break;
+ }
+ }
+ AST_LIST_TRAVERSE_SAFE_END;
+ AST_LIST_UNLOCK(&tls_objects);
+ if (to)
+ free(to);
+}
+
+void __ast_threadstorage_object_replace(void *key_old, void *key_new, size_t len)
+{
+ struct tls_object *to;
+
+ AST_LIST_LOCK(&tls_objects);
+ AST_LIST_TRAVERSE_SAFE_BEGIN(&tls_objects, to, entry) {
+ if (to->key == key_old) {
+ to->key = key_new;
+ to->size = len;
+ break;
+ }
+ }
+ AST_LIST_TRAVERSE_SAFE_END;
+ AST_LIST_UNLOCK(&tls_objects);
+}
+
+static int handle_show_allocations(int fd, int argc, char *argv[])
+{
+ char *fn = NULL;
+ size_t len = 0;
+ unsigned int count = 0;
+ struct tls_object *to;
+
+ if (argc > 3)
+ fn = argv[3];
+
+ AST_LIST_LOCK(&tls_objects);
+
+ AST_LIST_TRAVERSE(&tls_objects, to, entry) {
+ if (fn && strcasecmp(to->file, fn))
+ continue;
+
+ ast_cli(fd, "%10d bytes allocated in %20s at line %5d of %25s (thread %p)\n",
+ (int) to->size, to->function, to->line, to->file, (void *) to->thread);
+ len += to->size;
+ count++;
+ }
+
+ AST_LIST_UNLOCK(&tls_objects);
+
+ ast_cli(fd, "%10d bytes allocated in %d allocation%s\n", (int) len, count, count > 1 ? "s" : "");
+
+ return RESULT_SUCCESS;
+}
+
+static int handle_show_summary(int fd, int argc, char *argv[])
+{
+ char *fn = NULL;
+ size_t len = 0;
+ unsigned int count = 0;
+ struct tls_object *to;
+ struct file {
+ const char *name;
+ size_t len;
+ unsigned int count;
+ AST_LIST_ENTRY(file) entry;
+ } *file;
+ AST_LIST_HEAD_NOLOCK_STATIC(file_summary, file);
+
+ if (argc > 3)
+ fn = argv[3];
+
+ AST_LIST_LOCK(&tls_objects);
+
+ AST_LIST_TRAVERSE(&tls_objects, to, entry) {
+ if (fn && strcasecmp(to->file, fn))
+ continue;
+
+ AST_LIST_TRAVERSE(&file_summary, file, entry) {
+ if ((!fn && (file->name == to->file)) || (fn && (file->name == to->function)))
+ break;
+ }
+
+ if (!file) {
+ file = alloca(sizeof(*file));
+ memset(file, 0, sizeof(*file));
+ file->name = fn ? to->function : to->file;
+ AST_LIST_INSERT_TAIL(&file_summary, file, entry);
+ }
+
+ file->len += to->size;
+ file->count++;
+ }
+
+ AST_LIST_UNLOCK(&tls_objects);
+
+ AST_LIST_TRAVERSE(&file_summary, file, entry) {
+ len += file->len;
+ count += file->count;
+ if (fn) {
+ ast_cli(fd, "%10d bytes in %d allocation%ss in function %s\n",
+ (int) file->len, file->count, file->count > 1 ? "s" : "", file->name);
+ } else {
+ ast_cli(fd, "%10d bytes in %d allocation%s in file %s\n",
+ (int) file->len, file->count, file->count > 1 ? "s" : "", file->name);
+ }
+ }
+
+ ast_cli(fd, "%10d bytes allocated in %d allocation%s\n", (int) len, count, count > 1 ? "s" : "");
+
+ return RESULT_SUCCESS;
+}
+
+static struct ast_cli_entry cli[] = {
+ {
+ .cmda = { "threadstorage", "show", "allocations", NULL },
+ .handler = handle_show_allocations,
+ .summary = "Display outstanding thread local storage allocations",
+ .usage =
+ "Usage: threadstorage show allocations [<file>]\n"
+ " Dumps a list of all thread-specific memory allocations,\n"
+ "optionally limited to those from a specific file\n",
+ },
+ {
+ .cmda = { "threadstorage", "show", "summary", NULL },
+ .handler = handle_show_summary,
+ .summary = "Summarize outstanding memory allocations",
+ .usage =
+ "Usage: threadstorage show summary [<file>]\n"
+ " Summarizes thread-specific memory allocations by file, or optionally\n"
+ "by function, if a file is specified\n",
+ },
+};
+
+void threadstorage_init(void)
+{
+ ast_cli_register_multiple(cli, sizeof(cli) / sizeof(cli[0]));
+}
+
+#else /* !defined(DEBUG_THREADLOCALS) */
+
+void threadstorage_init(void)
+{
+}
+
+#endif /* !defined(DEBUG_THREADLOCALS) */
+
projects / thirdparty / asterisk.git / commitdiff
