1libtalloc_threads(3) talloc libtalloc_threads(3)
2
6 libtalloc_threads - Chapter 8: Using threads with talloc
7
10 The talloc library is not internally thread-safe, in that accesses to
11 variables on a talloc context are not controlled by mutexes or other
12 thread-safe primitives.
13 However, so long as talloc_disable_null_tracking() is called from the
15 main thread to disable global variable access within talloc, then each
16 thread can safely use its own top level talloc context allocated off
17 the NULL context.
18 For example:
20 static void *thread_fn(void *arg)
22 {
23 const char *ctx_name = (const char *)arg;
24 /*
25 * Create a new top level talloc hierarchy in
26 * this thread.
27 */
28 void *top_ctx = talloc_named_const(NULL, 0, "top");
29 if (top_ctx == NULL) {
30 return NULL;
31 }
32 sub_ctx = talloc_named_const(top_ctx, 100, ctx_name);
33 if (sub_ctx == NULL) {
34 return NULL;
35 }
36 /*
38 * Do more processing/talloc calls on top_ctx
39 * and its children.
40 */
41 ......
42 talloc_free(top_ctx);
44 return value;
45 }
46 is a perfectly safe use of talloc within a thread.
48 The problem comes when one thread wishes to move some memory allocated
50 on its local top level talloc context to another thread. Care must be
51 taken to add data access exclusion to prevent memory corruption. One
52 method would be to lock a mutex before any talloc call on each thread,
53 but this would push the burden of total talloc thread-safety on the
54 poor user of the library.
55 A much easier way to transfer talloced memory between threads is by the
57 use of an intermediate, mutex locked, intermediate variable.
58 An example of this is below - taken from test code inside the talloc
60 testsuite.
61 The main thread creates 1000 sub-threads, and then accepts the transfer
63 of some thread-talloc'ed memory onto its top level context from each
64 thread in turn.
65 A pthread mutex and condition variable are used to synchronize the
67 transfer via the intermediate_ptr variable.
68 /* Required sync variables. */
70 static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
71 static pthread_cond_t condvar = PTHREAD_COND_INITIALIZER;
72 /* Intermediate talloc pointer for transfer. */
74 static void *intermediate_ptr;
75 /* Subthread. */
77 static void *thread_fn(void *arg)
78 {
79 int ret;
80 const char *ctx_name = (const char *)arg;
81 void *sub_ctx = NULL;
82 /*
83 * Do stuff that creates a new talloc hierarchy in
84 * this thread.
85 */
86 void *top_ctx = talloc_named_const(NULL, 0, "top");
87 if (top_ctx == NULL) {
88 return NULL;
89 }
90 sub_ctx = talloc_named_const(top_ctx, 100, ctx_name);
91 if (sub_ctx == NULL) {
92 return NULL;
93 }
94 /*
96 * Now transfer a pointer from our hierarchy
97 * onto the intermediate ptr.
98 */
99 ret = pthread_mutex_lock(&mtx);
100 if (ret != 0) {
101 talloc_free(top_ctx);
102 return NULL;
103 }
104 /* Wait for intermediate_ptr to be free. */
106 while (intermediate_ptr != NULL) {
107 ret = pthread_cond_wait(&condvar, &mtx);
108 if (ret != 0) {
109 talloc_free(top_ctx);
110 return NULL;
111 }
112 }
113 /* and move our memory onto it from our toplevel hierarchy. */
115 intermediate_ptr = talloc_move(NULL, &sub_ctx);
116 /* Tell the main thread it's ready for pickup. */
118 pthread_cond_broadcast(&condvar);
119 pthread_mutex_unlock(&mtx);
120 talloc_free(top_ctx);
122 return NULL;
123 }
124 /* Main thread. */
126 #define NUM_THREADS 1000
128 static bool test_pthread_talloc_passing(void)
130 {
131 int i;
132 int ret;
133 char str_array[NUM_THREADS][20];
134 pthread_t thread_id;
135 void *mem_ctx;
136 /*
138 * Important ! Null tracking breaks threaded talloc.
139 * It *must* be turned off.
140 */
141 talloc_disable_null_tracking();
142 /* Main thread toplevel context. */
144 mem_ctx = talloc_named_const(NULL, 0, "toplevel");
145 if (mem_ctx == NULL) {
146 return false;
147 }
148 /*
150 * Spin off NUM_THREADS threads.
151 * They will use their own toplevel contexts.
152 */
153 for (i = 0; i < NUM_THREADS; i++) {
154 (void)snprintf(str_array[i],
155 20,
156 "thread:%d",
157 i);
158 if (str_array[i] == NULL) {
159 return false;
160 }
161 ret = pthread_create(&thread_id,
162 NULL,
163 thread_fn,
164 str_array[i]);
165 if (ret != 0) {
166 return false;
167 }
168 }
169 /* Now wait for NUM_THREADS transfers of the talloc'ed memory. */
171 for (i = 0; i < NUM_THREADS; i++) {
172 ret = pthread_mutex_lock(&mtx);
173 if (ret != 0) {
174 talloc_free(mem_ctx);
175 return false;
176 }
177 /* Wait for intermediate_ptr to have our data. */
179 while (intermediate_ptr == NULL) {
180 ret = pthread_cond_wait(&condvar, &mtx);
181 if (ret != 0) {
182 talloc_free(mem_ctx);
183 return false;
184 }
185 }
186 /* and move it onto our toplevel hierarchy. */
188 (void)talloc_move(mem_ctx, &intermediate_ptr);
189 /* Tell the sub-threads we're ready for another. */
191 pthread_cond_broadcast(&condvar);
192 pthread_mutex_unlock(&mtx);
193 }
194 /* Dump the hierarchy. */
196 talloc_report(mem_ctx, stdout);
197 talloc_free(mem_ctx);
198 return true;
199 }
200Version 2.0 Wed Sep 11 2019 libtalloc_threads(3)