heimdal Extra files required for merge up to current heimdal
[sfrench/samba-autobuild/.git] / source4 / heimdal / base / heimbase.c
1 /*
2  * Copyright (c) 2010 Kungliga Tekniska Högskolan
3  * (Royal Institute of Technology, Stockholm, Sweden).
4  * All rights reserved.
5  *
6  * Portions Copyright (c) 2010 Apple Inc. All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * 3. Neither the name of the Institute nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  */
35
36 #include "baselocl.h"
37 #include <syslog.h>
38
39 static heim_base_atomic_type tidglobal = HEIM_TID_USER;
40
41 struct heim_base {
42     heim_type_t isa;
43     heim_base_atomic_type ref_cnt;
44     HEIM_TAILQ_ENTRY(heim_base) autorel;
45     heim_auto_release_t autorelpool;
46     uintptr_t isaextra[3];
47 };
48
49 /* specialized version of base */
50 struct heim_base_mem {
51     heim_type_t isa;
52     heim_base_atomic_type ref_cnt;
53     HEIM_TAILQ_ENTRY(heim_base) autorel;
54     heim_auto_release_t autorelpool;
55     const char *name;
56     void (*dealloc)(void *);
57     uintptr_t isaextra[1];
58 };
59
60 #define PTR2BASE(ptr) (((struct heim_base *)ptr) - 1)
61 #define BASE2PTR(ptr) ((void *)(((struct heim_base *)ptr) + 1))
62
63 /*
64  * Auto release structure
65  */
66
67 struct heim_auto_release {
68     HEIM_TAILQ_HEAD(, heim_base) pool;
69     HEIMDAL_MUTEX pool_mutex;
70     struct heim_auto_release *parent;
71 };
72
73
74 /**
75  * Retain object
76  *
77  * @param object to be released, NULL is ok
78  *
79  * @return the same object as passed in
80  */
81
82 void *
83 heim_retain(void *ptr)
84 {
85     struct heim_base *p = PTR2BASE(ptr);
86
87     if (ptr == NULL || heim_base_is_tagged(ptr))
88         return ptr;
89
90     if (p->ref_cnt == heim_base_atomic_max)
91         return ptr;
92
93     if ((heim_base_atomic_inc(&p->ref_cnt) - 1) == 0)
94         heim_abort("resurection");
95     return ptr;
96 }
97
98 /**
99  * Release object, free is reference count reaches zero
100  *
101  * @param object to be released
102  */
103
104 void
105 heim_release(void *ptr)
106 {
107     heim_base_atomic_type old;
108     struct heim_base *p = PTR2BASE(ptr);
109
110     if (ptr == NULL || heim_base_is_tagged(ptr))
111         return;
112
113     if (p->ref_cnt == heim_base_atomic_max)
114         return;
115
116     old = heim_base_atomic_dec(&p->ref_cnt) + 1;
117
118     if (old > 1)
119         return;
120
121     if (old == 1) {
122         heim_auto_release_t ar = p->autorelpool;
123         /* remove from autorel pool list */
124         if (ar) {
125             p->autorelpool = NULL;
126             HEIMDAL_MUTEX_lock(&ar->pool_mutex);
127             HEIM_TAILQ_REMOVE(&ar->pool, p, autorel);
128             HEIMDAL_MUTEX_unlock(&ar->pool_mutex);
129         }
130         if (p->isa->dealloc)
131             p->isa->dealloc(ptr);
132         free(p);
133     } else
134         heim_abort("over release");
135 }
136
137 static heim_type_t tagged_isa[9] = {
138     &_heim_number_object,
139     &_heim_null_object,
140     &_heim_bool_object,
141
142     NULL,
143     NULL,
144     NULL,
145
146     NULL,
147     NULL,
148     NULL
149 };
150
151 heim_type_t
152 _heim_get_isa(heim_object_t ptr)
153 {
154     struct heim_base *p;
155     if (heim_base_is_tagged(ptr)) {
156         if (heim_base_is_tagged_object(ptr))
157             return tagged_isa[heim_base_tagged_object_tid(ptr)];
158         if (heim_base_is_tagged_string(ptr))
159             return &_heim_string_object;
160         heim_abort("not a supported tagged type");
161     }
162     p = PTR2BASE(ptr);
163     return p->isa;
164 }
165
166 /**
167  * Get type ID of object
168  *
169  * @param object object to get type id of
170  *
171  * @return type id of object
172  */
173
174 heim_tid_t
175 heim_get_tid(heim_object_t ptr)
176 {
177     heim_type_t isa = _heim_get_isa(ptr);
178     return isa->tid;
179 }
180
181 /**
182  * Get hash value of object
183  *
184  * @param object object to get hash value for
185  *
186  * @return a hash value
187  */
188
189 unsigned long
190 heim_get_hash(heim_object_t ptr)
191 {
192     heim_type_t isa = _heim_get_isa(ptr);
193     if (isa->hash)
194         return isa->hash(ptr);
195     return (unsigned long)ptr;
196 }
197
198 /**
199  * Compare two objects, returns 0 if equal, can use used for qsort()
200  * and friends.
201  *
202  * @param a first object to compare
203  * @param b first object to compare
204  *
205  * @return 0 if objects are equal
206  */
207
208 int
209 heim_cmp(heim_object_t a, heim_object_t b)
210 {
211     heim_tid_t ta, tb;
212     heim_type_t isa;
213
214     ta = heim_get_tid(a);
215     tb = heim_get_tid(b);
216
217     if (ta != tb)
218         return ta - tb;
219
220     isa = _heim_get_isa(a);
221
222     if (isa->cmp)
223         return isa->cmp(a, b);
224
225     return (uintptr_t)a - (uintptr_t)b;
226 }
227
228 /*
229  * Private - allocates an memory object
230  */
231
232 static void
233 memory_dealloc(void *ptr)
234 {
235     struct heim_base_mem *p = (struct heim_base_mem *)PTR2BASE(ptr);
236     if (p->dealloc)
237         p->dealloc(ptr);
238 }
239
240 struct heim_type_data memory_object = {
241     HEIM_TID_MEMORY,
242     "memory-object",
243     NULL,
244     memory_dealloc,
245     NULL,
246     NULL,
247     NULL
248 };
249
250 void *
251 heim_alloc(size_t size, const char *name, heim_type_dealloc dealloc)
252 {
253     /* XXX use posix_memalign */
254
255     struct heim_base_mem *p = calloc(1, size + sizeof(*p));
256     if (p == NULL)
257         return NULL;
258     p->isa = &memory_object;
259     p->ref_cnt = 1;
260     p->name = name;
261     p->dealloc = dealloc;
262     return BASE2PTR(p);
263 }
264
265 heim_type_t
266 _heim_create_type(const char *name,
267                   heim_type_init init,
268                   heim_type_dealloc dealloc,
269                   heim_type_copy copy,
270                   heim_type_cmp cmp,
271                   heim_type_hash hash)
272 {
273     heim_type_t type;
274
275     type = calloc(1, sizeof(*type));
276     if (type == NULL)
277         return NULL;
278
279     type->tid = heim_base_atomic_inc(&tidglobal);
280     type->name = name;
281     type->init = init;
282     type->dealloc = dealloc;
283     type->copy = copy;
284     type->cmp = cmp;
285     type->hash = hash;
286
287     return type;
288 }
289
290 heim_object_t
291 _heim_alloc_object(heim_type_t type, size_t size)
292 {
293     /* XXX should use posix_memalign */
294     struct heim_base *p = calloc(1, size + sizeof(*p));
295     if (p == NULL)
296         return NULL;
297     p->isa = type;
298     p->ref_cnt = 1;
299
300     return BASE2PTR(p);
301 }
302
303 heim_tid_t
304 _heim_type_get_tid(heim_type_t type)
305 {
306     return type->tid;
307 }
308
309 /**
310  * Call func once and only once
311  *
312  * @param once pointer to a heim_base_once_t
313  * @param ctx context passed to func
314  * @param func function to be called
315  */
316
317 void
318 heim_base_once_f(heim_base_once_t *once, void *ctx, void (*func)(void *))
319 {
320 #ifdef HAVE_DISPATCH_DISPATCH_H
321     dispatch_once_f(once, ctx, func);
322 #else
323     static HEIMDAL_MUTEX mutex = HEIMDAL_MUTEX_INITIALIZER;
324     HEIMDAL_MUTEX_lock(&mutex);
325     if (*once == 0) {
326         *once = 1;
327         HEIMDAL_MUTEX_unlock(&mutex);
328         func(ctx);
329         HEIMDAL_MUTEX_lock(&mutex);
330         *once = 2;
331         HEIMDAL_MUTEX_unlock(&mutex);
332     } else if (*once == 2) {
333         HEIMDAL_MUTEX_unlock(&mutex);
334     } else {
335         HEIMDAL_MUTEX_unlock(&mutex);
336         while (1) {
337             struct timeval tv = { 0, 1000 };
338             HEIMDAL_MUTEX_lock(&mutex);
339             if (*once == 2)
340                 break;
341             HEIMDAL_MUTEX_unlock(&mutex);
342         }
343         HEIMDAL_MUTEX_unlock(&mutex);
344     }
345 #endif
346 }
347
348 /**
349  * Abort and log the failure (using syslog)
350  */
351
352 void
353 heim_abort(const char *fmt, ...)
354 {
355     va_list ap;
356     va_start(ap, fmt);
357     heim_abortv(fmt, ap);
358     va_end(ap);
359 }
360
361 /**
362  * Abort and log the failure (using syslog)
363  */
364
365 void
366 heim_abortv(const char *fmt, va_list ap)
367 {
368     char *str = NULL;
369     int ret;
370
371     ret = vasprintf(&str, fmt, ap);
372     if (ret > 0 && str) {
373         syslog(LOG_ERR, "heim_abort: %s", str);
374     }
375     abort();
376 }
377
378 /*
379  *
380  */
381
382 static int ar_created = 0;
383 static HEIMDAL_thread_key ar_key;
384
385 struct ar_tls {
386     struct heim_auto_release *head;
387     struct heim_auto_release *current;
388     HEIMDAL_MUTEX tls_mutex;
389 };
390
391 static void
392 ar_tls_delete(void *ptr)
393 {
394     struct ar_tls *tls = ptr;
395     if (tls->head)
396         heim_release(tls->head);
397     free(tls);
398 }
399
400 static void
401 init_ar_tls(void *ptr)
402 {
403     int ret;
404     HEIMDAL_key_create(&ar_key, ar_tls_delete, ret);
405     if (ret == 0)
406         ar_created = 1;
407 }
408
409 static struct ar_tls *
410 autorel_tls(void)
411 {
412     static heim_base_once_t once = HEIM_BASE_ONCE_INIT;
413     struct ar_tls *arp;
414     int ret;
415
416     heim_base_once_f(&once, NULL, init_ar_tls);
417     if (!ar_created)
418         return NULL;
419
420     arp = HEIMDAL_getspecific(ar_key);
421     if (arp == NULL) {
422
423         arp = calloc(1, sizeof(*arp));
424         if (arp == NULL)
425             return NULL;
426         HEIMDAL_setspecific(ar_key, arp, ret);
427         if (ret) {
428             free(arp);
429             return NULL;
430         }
431     }
432     return arp;
433
434 }
435
436 static void
437 autorel_dealloc(void *ptr)
438 {
439     heim_auto_release_t ar = ptr;
440     struct ar_tls *tls;
441
442     tls = autorel_tls();
443     if (tls == NULL)
444         heim_abort("autorelease pool released on thread w/o autorelease inited");
445
446     heim_auto_release_drain(ar);
447
448     if (!HEIM_TAILQ_EMPTY(&ar->pool))
449         heim_abort("pool not empty after draining");
450
451     HEIMDAL_MUTEX_lock(&tls->tls_mutex);
452     if (tls->current != ptr)
453         heim_abort("autorelease not releaseing top pool");
454
455     if (tls->current != tls->head)
456         tls->current = ar->parent;
457     HEIMDAL_MUTEX_unlock(&tls->tls_mutex);
458 }
459
460 static int
461 autorel_cmp(void *a, void *b)
462 {
463     return (a == b);
464 }
465
466 static unsigned long
467 autorel_hash(void *ptr)
468 {
469     return (unsigned long)ptr;
470 }
471
472
473 static struct heim_type_data _heim_autorel_object = {
474     HEIM_TID_AUTORELEASE,
475     "autorelease-pool",
476     NULL,
477     autorel_dealloc,
478     NULL,
479     autorel_cmp,
480     autorel_hash
481 };
482
483 /**
484  *
485  */
486
487 heim_auto_release_t
488 heim_auto_release_create(void)
489 {
490     struct ar_tls *tls = autorel_tls();
491     heim_auto_release_t ar;
492
493     if (tls == NULL)
494         heim_abort("Failed to create/get autorelease head");
495
496     ar = _heim_alloc_object(&_heim_autorel_object, sizeof(struct heim_auto_release));
497     if (ar) {
498         HEIMDAL_MUTEX_lock(&tls->tls_mutex);
499         if (tls->head == NULL)
500             tls->head = ar;
501         ar->parent = tls->current;
502         tls->current = ar;
503         HEIMDAL_MUTEX_unlock(&tls->tls_mutex);
504     }
505
506     return ar;
507 }
508
509 /**
510  * Mark the current object as a
511  */
512
513 void
514 heim_auto_release(heim_object_t ptr)
515 {
516     struct heim_base *p = PTR2BASE(ptr);
517     struct ar_tls *tls = autorel_tls();
518     heim_auto_release_t ar;
519
520     if (ptr == NULL || heim_base_is_tagged(ptr))
521         return;
522
523     /* drop from old pool */
524     if ((ar = p->autorelpool) != NULL) {
525         HEIMDAL_MUTEX_lock(&ar->pool_mutex);
526         HEIM_TAILQ_REMOVE(&ar->pool, p, autorel);
527         p->autorelpool = NULL;
528         HEIMDAL_MUTEX_unlock(&ar->pool_mutex);
529     }
530
531     if (tls == NULL || (ar = tls->current) == NULL)
532         heim_abort("no auto relase pool in place, would leak");
533
534     HEIMDAL_MUTEX_lock(&ar->pool_mutex);
535     HEIM_TAILQ_INSERT_HEAD(&ar->pool, p, autorel);
536     p->autorelpool = ar;
537     HEIMDAL_MUTEX_unlock(&ar->pool_mutex);
538 }
539
540 /**
541  *
542  */
543
544 void
545 heim_auto_release_drain(heim_auto_release_t autorel)
546 {
547     heim_object_t obj;
548
549     /* release all elements on the tail queue */
550
551     HEIMDAL_MUTEX_lock(&autorel->pool_mutex);
552     while(!HEIM_TAILQ_EMPTY(&autorel->pool)) {
553         obj = HEIM_TAILQ_FIRST(&autorel->pool);
554         HEIMDAL_MUTEX_unlock(&autorel->pool_mutex);
555         heim_release(BASE2PTR(obj));
556         HEIMDAL_MUTEX_lock(&autorel->pool_mutex);
557     }
558     HEIMDAL_MUTEX_unlock(&autorel->pool_mutex);
559 }