f1727ce469d87594d20061c9b925234daa9abf94
[ira/wip.git] / lib / util / talloc_stack.c
1 /*
2    Unix SMB/CIFS implementation.
3    Implement a stack of talloc contexts
4    Copyright (C) Volker Lendecke 2007
5    Copyright (C) Jeremy Allison 2009 - made thread safe.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 /*
23  * Implement a stack of talloc frames.
24  *
25  * When a new talloc stackframe is allocated with talloc_stackframe(), then
26  * the TALLOC_CTX returned with talloc_tos() is reset to that new
27  * frame. Whenever that stack frame is TALLOC_FREE()'ed, then the reverse
28  * happens: The previous talloc_tos() is restored.
29  *
30  * This API is designed to be robust in the sense that if someone forgets to
31  * TALLOC_FREE() a stackframe, then the next outer one correctly cleans up and
32  * resets the talloc_tos().
33  *
34  * This robustness feature means that we can't rely on a linked list with
35  * talloc destructors because in a hierarchy of talloc destructors the parent
36  * destructor is called before its children destructors. The child destructor
37  * called after the parent would set the talloc_tos() to the wrong value.
38  */
39
40 #include "includes.h"
41
42 struct talloc_stackframe {
43         int talloc_stacksize;
44         int talloc_stack_arraysize;
45         TALLOC_CTX **talloc_stack;
46 };
47
48 /*
49  * In the single threaded case this is a pointer
50  * to the global talloc_stackframe. In the MT-case
51  * this is the pointer to the thread-specific key
52  * used to look up the per-thread talloc_stackframe
53  * pointer.
54  */
55
56 static void *global_ts;
57
58 /* Variable to ensure TLS value is only initialized once. */
59 static smb_thread_once_t ts_initialized = SMB_THREAD_ONCE_INIT;
60
61 static void talloc_stackframe_init(void * unused)
62 {
63         if (!global_tfp) {
64                 /* Non-thread safe init case. */
65                 if (SMB_THREAD_ONCE_IS_INITIALIZED(ts_initialized)) {
66                         return;
67                 }
68                 SMB_THREAD_ONCE_INITIALIZE(ts_initialized);
69         }
70
71         if (SMB_THREAD_CREATE_TLS("talloc_stackframe", global_ts)) {
72                 smb_panic("talloc_stackframe_init create_tls failed");
73         }
74 }
75
76 static struct talloc_stackframe *talloc_stackframe_create(void)
77 {
78 #if defined(PARANOID_MALLOC_CHECKER)
79 #ifdef malloc
80 #undef malloc
81 #endif
82 #endif
83         struct talloc_stackframe *ts =
84                 (struct talloc_stackframe *)malloc(sizeof(struct talloc_stackframe));
85 #if defined(PARANOID_MALLOC_CHECKER)
86 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
87 #endif
88
89         if (!ts) {
90                 smb_panic("talloc_stackframe_init malloc failed");
91         }
92
93         ZERO_STRUCTP(ts);
94
95         SMB_THREAD_ONCE(&ts_initialized, talloc_stackframe_init, NULL);
96
97         if (SMB_THREAD_SET_TLS(global_ts, ts)) {
98                 smb_panic("talloc_stackframe_init set_tls failed");
99         }
100         return ts;
101 }
102
103 static int talloc_pop(TALLOC_CTX *frame)
104 {
105         struct talloc_stackframe *ts =
106                 (struct talloc_stackframe *)SMB_THREAD_GET_TLS(global_ts);
107         int i;
108
109         for (i=ts->talloc_stacksize-1; i>0; i--) {
110                 if (frame == ts->talloc_stack[i]) {
111                         break;
112                 }
113                 talloc_free(ts->talloc_stack[i]);
114         }
115
116         ts->talloc_stacksize = i;
117         return 0;
118 }
119
120 /*
121  * Create a new talloc stack frame.
122  *
123  * When free'd, it frees all stack frames that were created after this one and
124  * not explicitly freed.
125  */
126
127 static TALLOC_CTX *talloc_stackframe_internal(size_t poolsize)
128 {
129         TALLOC_CTX **tmp, *top, *parent;
130         struct talloc_stackframe *ts =
131                 (struct talloc_stackframe *)SMB_THREAD_GET_TLS(global_ts);
132
133         if (ts == NULL) {
134                 ts = talloc_stackframe_create();
135         }
136
137         if (ts->talloc_stack_arraysize < ts->talloc_stacksize + 1) {
138                 tmp = talloc_realloc(NULL, ts->talloc_stack, TALLOC_CTX *,
139                                            ts->talloc_stacksize + 1);
140                 if (tmp == NULL) {
141                         goto fail;
142                 }
143                 ts->talloc_stack = tmp;
144                 ts->talloc_stack_arraysize = ts->talloc_stacksize + 1;
145         }
146
147         if (ts->talloc_stacksize == 0) {
148                 parent = ts->talloc_stack;
149         } else {
150                 parent = ts->talloc_stack[ts->talloc_stacksize-1];
151         }
152
153         if (poolsize) {
154                 top = talloc_pool(parent, poolsize);
155         } else {
156                 top = talloc_new(parent);
157         }
158
159         if (top == NULL) {
160                 goto fail;
161         }
162
163         talloc_set_destructor(top, talloc_pop);
164
165         ts->talloc_stack[ts->talloc_stacksize++] = top;
166         return top;
167
168  fail:
169         smb_panic("talloc_stackframe failed");
170         return NULL;
171 }
172
173 TALLOC_CTX *talloc_stackframe(void)
174 {
175         return talloc_stackframe_internal(0);
176 }
177
178 TALLOC_CTX *talloc_stackframe_pool(size_t poolsize)
179 {
180         return talloc_stackframe_internal(poolsize);
181 }
182
183 /*
184  * Get us the current top of the talloc stack.
185  */
186
187 TALLOC_CTX *talloc_tos(void)
188 {
189         struct talloc_stackframe *ts =
190                 (struct talloc_stackframe *)SMB_THREAD_GET_TLS(global_ts);
191
192         if (ts == NULL) {
193                 talloc_stackframe();
194                 ts = (struct talloc_stackframe *)SMB_THREAD_GET_TLS(global_ts);
195                 DEBUG(0, ("no talloc stackframe around, leaking memory\n"));
196         }
197
198         return ts->talloc_stack[ts->talloc_stacksize-1];
199 }