Unix SMB/CIFS implementation.
Implement a stack of talloc contexts
Copyright (C) Volker Lendecke 2007
+ Copyright (C) Jeremy Allison 2009 - made thread safe.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "includes.h"
-static int talloc_stacksize;
-static int talloc_stack_arraysize;
-static TALLOC_CTX **talloc_stack;
+struct talloc_stackframe {
+ int talloc_stacksize;
+ int talloc_stack_arraysize;
+ TALLOC_CTX **talloc_stack;
+};
+
+/*
+ * In the single threaded case this is a pointer
+ * to the global talloc_stackframe. In the MT-case
+ * this is the pointer to the thread-specific key
+ * used to look up the per-thread talloc_stackframe
+ * pointer.
+ */
+
+static void *global_ts;
+
+/* Variable to ensure TLS value is only initialized once. */
+static smb_thread_once_t ts_initialized = SMB_THREAD_ONCE_INIT;
+
+static void talloc_stackframe_init(void * unused)
+{
+ if (SMB_THREAD_CREATE_TLS("talloc_stackframe", global_ts)) {
+ smb_panic("talloc_stackframe_init create_tls failed");
+ }
+}
+
+static struct talloc_stackframe *talloc_stackframe_create(void)
+{
+#if defined(PARANOID_MALLOC_CHECKER)
+#ifdef calloc
+#undef calloc
+#endif
+#endif
+ struct talloc_stackframe *ts = (struct talloc_stackframe *)calloc(
+ 1, sizeof(struct talloc_stackframe));
+#if defined(PARANOID_MALLOC_CHECKER)
+#define calloc(n, s) __ERROR_DONT_USE_MALLOC_DIRECTLY
+#endif
+
+ if (!ts) {
+ smb_panic("talloc_stackframe_init malloc failed");
+ }
+
+ SMB_THREAD_ONCE(&ts_initialized, talloc_stackframe_init, NULL);
+
+ if (SMB_THREAD_SET_TLS(global_ts, ts)) {
+ smb_panic("talloc_stackframe_init set_tls failed");
+ }
+ return ts;
+}
static int talloc_pop(TALLOC_CTX *frame)
{
+ struct talloc_stackframe *ts =
+ (struct talloc_stackframe *)SMB_THREAD_GET_TLS(global_ts);
int i;
- for (i=talloc_stacksize-1; i>0; i--) {
- if (frame == talloc_stack[i]) {
+ /* Catch lazy frame-freeing. */
+ if (ts->talloc_stack[ts->talloc_stacksize-1] != frame) {
+ DEBUG(0, ("Freed frame %s, expected %s.\n",
+ talloc_get_name(frame),
+ talloc_get_name(ts->talloc_stack
+ [ts->talloc_stacksize-1])));
+#ifdef DEVELOPER
+ smb_panic("Frame not freed in order.");
+#endif
+ }
+
+ for (i=ts->talloc_stacksize-1; i>0; i--) {
+ if (frame == ts->talloc_stack[i]) {
break;
}
- talloc_free(talloc_stack[i]);
+ TALLOC_FREE(ts->talloc_stack[i]);
}
- talloc_stacksize = i;
+ ts->talloc_stack[i] = NULL;
+ ts->talloc_stacksize = i;
return 0;
}
* not explicitly freed.
*/
-static TALLOC_CTX *talloc_stackframe_internal(size_t poolsize)
+static TALLOC_CTX *talloc_stackframe_internal(const char *location,
+ size_t poolsize)
{
- TALLOC_CTX **tmp, *top, *parent;
+ TALLOC_CTX **tmp, *top;
+ struct talloc_stackframe *ts =
+ (struct talloc_stackframe *)SMB_THREAD_GET_TLS(global_ts);
+
+ if (ts == NULL) {
+ ts = talloc_stackframe_create();
+ }
- if (talloc_stack_arraysize < talloc_stacksize + 1) {
- tmp = talloc_realloc(NULL, talloc_stack, TALLOC_CTX *,
- talloc_stacksize + 1);
+ if (ts->talloc_stack_arraysize < ts->talloc_stacksize + 1) {
+ tmp = talloc_realloc(NULL, ts->talloc_stack, TALLOC_CTX *,
+ ts->talloc_stacksize + 1);
if (tmp == NULL) {
goto fail;
}
- talloc_stack = tmp;
- talloc_stack_arraysize = talloc_stacksize + 1;
+ ts->talloc_stack = tmp;
+ ts->talloc_stack_arraysize = ts->talloc_stacksize + 1;
}
- if (talloc_stacksize == 0) {
- parent = talloc_stack;
- }
- else {
- parent = talloc_stack[talloc_stacksize-1];
- }
-
if (poolsize) {
- top = talloc_pool(parent, poolsize);
+ top = talloc_pool(ts->talloc_stack, poolsize);
} else {
+ TALLOC_CTX *parent;
+ /* We chain parentage, so if one is a pool we draw from it. */
+ if (ts->talloc_stacksize == 0) {
+ parent = ts->talloc_stack;
+ } else {
+ parent = ts->talloc_stack[ts->talloc_stacksize-1];
+ }
top = talloc_new(parent);
}
if (top == NULL) {
goto fail;
}
-
+ talloc_set_name_const(top, location);
talloc_set_destructor(top, talloc_pop);
- talloc_stack[talloc_stacksize++] = top;
+ ts->talloc_stack[ts->talloc_stacksize++] = top;
return top;
fail:
return NULL;
}
-TALLOC_CTX *talloc_stackframe(void)
+TALLOC_CTX *_talloc_stackframe(const char *location)
{
- return talloc_stackframe_internal(0);
+ return talloc_stackframe_internal(location, 0);
}
-TALLOC_CTX *talloc_stackframe_pool(size_t poolsize)
+TALLOC_CTX *_talloc_stackframe_pool(const char *location, size_t poolsize)
{
- return talloc_stackframe_internal(poolsize);
+ return talloc_stackframe_internal(location, poolsize);
}
/*
* Get us the current top of the talloc stack.
*/
-TALLOC_CTX *talloc_tos(void)
+TALLOC_CTX *_talloc_tos(const char *location)
{
- if (talloc_stacksize == 0) {
- talloc_stackframe();
- DEBUG(0, ("no talloc stackframe around, leaking memory\n"));
+ struct talloc_stackframe *ts =
+ (struct talloc_stackframe *)SMB_THREAD_GET_TLS(global_ts);
+
+ if (ts == NULL || ts->talloc_stacksize == 0) {
+ _talloc_stackframe(location);
+ ts = (struct talloc_stackframe *)SMB_THREAD_GET_TLS(global_ts);
+ DEBUG(0, ("no talloc stackframe at %s, leaking memory\n",
+ location));
+#ifdef DEVELOPER
+ smb_panic("No talloc stackframe");
+#endif
}
- return talloc_stack[talloc_stacksize-1];
+ return ts->talloc_stack[ts->talloc_stacksize-1];
+}
+
+/*
+ * return true if a talloc stackframe exists
+ * this can be used to prevent memory leaks for code that can
+ * optionally use a talloc stackframe (eg. nt_errstr())
+ */
+
+bool talloc_stackframe_exists(void)
+{
+ struct talloc_stackframe *ts =
+ (struct talloc_stackframe *)SMB_THREAD_GET_TLS(global_ts);
+
+ if (ts == NULL || ts->talloc_stacksize == 0) {
+ return false;
+ }
+ return true;
}