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