[BACK]Return to thread-stub.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / libc / thread-stub

Annotation of src/lib/libc/thread-stub/thread-stub.c, Revision 1.28

1.28    ! kamil       1: /*     $NetBSD: thread-stub.c,v 1.27 2013/05/28 17:29:41 christos Exp $        */
1.2       thorpej     2:
                      3: /*-
1.21      ad          4:  * Copyright (c) 2003, 2009 The NetBSD Foundation, Inc.
1.2       thorpej     5:  * All rights reserved.
                      6:  *
                      7:  * This code is derived from software contributed to The NetBSD Foundation
                      8:  * by Jason R. Thorpe.
                      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:  * 1. Redistributions of source code must retain the above copyright
                     14:  *    notice, this list of conditions and the following disclaimer.
                     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:  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
                     20:  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
                     21:  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
                     22:  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
                     23:  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
                     24:  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
                     25:  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
                     26:  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
                     27:  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
                     28:  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
                     29:  * POSSIBILITY OF SUCH DAMAGE.
                     30:  */
                     31:
1.13      lukem      32: #include <sys/cdefs.h>
                     33: #if defined(LIBC_SCCS) && !defined(lint)
1.28    ! kamil      34: __RCSID("$NetBSD: thread-stub.c,v 1.27 2013/05/28 17:29:41 christos Exp $");
1.13      lukem      35: #endif /* LIBC_SCCS and not lint */
                     36:
1.2       thorpej    37: /*
                     38:  * Stubs for thread operations, for use when threads are not used by
                     39:  * the application.  See "reentrant.h" for details.
                     40:  */
                     41:
                     42: #ifdef _REENTRANT
                     43:
                     44: #define        __LIBC_THREAD_STUBS
                     45:
1.26      joerg      46: #define pthread_join   __libc_pthread_join
                     47: #define pthread_detach __libc_pthread_detach
1.2       thorpej    48: #include "namespace.h"
                     49: #include "reentrant.h"
                     50:
1.5       thorpej    51: #include <errno.h>
1.2       thorpej    52: #include <signal.h>
1.8       matt       53: #include <stdlib.h>
1.2       thorpej    54: #include <unistd.h>
                     55:
                     56: extern int __isthreaded;
                     57:
1.21      ad         58: #define        DIE()   (void)raise(SIGABRT)
1.2       thorpej    59:
                     60: #define        CHECK_NOT_THREADED_ALWAYS()     \
                     61: do {                                   \
                     62:        if (__isthreaded)               \
                     63:                DIE();                  \
                     64: } while (/*CONSTCOND*/0)
                     65:
                     66: #if 1
                     67: #define        CHECK_NOT_THREADED()    CHECK_NOT_THREADED_ALWAYS()
                     68: #else
                     69: #define        CHECK_NOT_THREADED()    /* nothing */
                     70: #endif
                     71:
1.26      joerg      72: __weak_alias(pthread_join, __libc_pthread_join)
                     73: __weak_alias(pthread_detach, __libc_pthread_detach)
                     74:
                     75: int
                     76: pthread_join(pthread_t thread, void **valptr)
                     77: {
                     78:
                     79:        if (thread == pthread_self())
                     80:                return EDEADLK;
                     81:        return ESRCH;
                     82: }
                     83:
                     84: int
                     85: pthread_detach(pthread_t thread)
                     86: {
                     87:
                     88:        if (thread == pthread_self())
                     89:                return 0;
                     90:        return ESRCH;
                     91: }
                     92:
1.2       thorpej    93: /* mutexes */
                     94:
1.23      christos   95: int __libc_mutex_catchall_stub(mutex_t *);
1.2       thorpej    96:
                     97: __weak_alias(__libc_mutex_init,__libc_mutex_init_stub)
                     98: __weak_alias(__libc_mutex_lock,__libc_mutex_catchall_stub)
                     99: __weak_alias(__libc_mutex_trylock,__libc_mutex_catchall_stub)
                    100: __weak_alias(__libc_mutex_unlock,__libc_mutex_catchall_stub)
                    101: __weak_alias(__libc_mutex_destroy,__libc_mutex_catchall_stub)
                    102:
1.23      christos  103: __strong_alias(__libc_mutex_lock_stub,__libc_mutex_catchall_stub)
                    104: __strong_alias(__libc_mutex_trylock_stub,__libc_mutex_catchall_stub)
                    105: __strong_alias(__libc_mutex_unlock_stub,__libc_mutex_catchall_stub)
                    106: __strong_alias(__libc_mutex_destroy_stub,__libc_mutex_catchall_stub)
                    107:
                    108: int __libc_mutexattr_catchall_stub(mutexattr_t *);
1.4       thorpej   109:
                    110: __weak_alias(__libc_mutexattr_init,__libc_mutexattr_catchall_stub)
                    111: __weak_alias(__libc_mutexattr_destroy,__libc_mutexattr_catchall_stub)
                    112: __weak_alias(__libc_mutexattr_settype,__libc_mutexattr_settype_stub)
                    113:
1.23      christos  114: __strong_alias(__libc_mutexattr_init_stub,__libc_mutexattr_catchall_stub)
                    115: __strong_alias(__libc_mutexattr_destroy_stub,__libc_mutexattr_catchall_stub)
                    116:
1.2       thorpej   117: int
                    118: __libc_mutex_init_stub(mutex_t *m, const mutexattr_t *a)
                    119: {
                    120:        /* LINTED deliberate lack of effect */
                    121:        (void)m;
                    122:        /* LINTED deliberate lack of effect */
                    123:        (void)a;
                    124:
                    125:        CHECK_NOT_THREADED();
                    126:
                    127:        return (0);
                    128: }
                    129:
                    130: int
                    131: __libc_mutex_catchall_stub(mutex_t *m)
                    132: {
                    133:        /* LINTED deliberate lack of effect */
                    134:        (void)m;
                    135:
                    136:        CHECK_NOT_THREADED();
                    137:
                    138:        return (0);
                    139: }
                    140:
1.4       thorpej   141: int
                    142: __libc_mutexattr_settype_stub(mutexattr_t *ma, int type)
                    143: {
                    144:        /* LINTED deliberate lack of effect */
                    145:        (void)ma;
                    146:        /* LINTED deliberate lack of effect */
                    147:        (void)type;
                    148:
1.28    ! kamil     149:        CHECK_NOT_THREADED();
        !           150:
1.4       thorpej   151:        return (0);
                    152: }
                    153:
                    154: int
                    155: __libc_mutexattr_catchall_stub(mutexattr_t *ma)
                    156: {
                    157:        /* LINTED deliberate lack of effect */
                    158:        (void)ma;
                    159:
                    160:        CHECK_NOT_THREADED();
                    161:
                    162:        return (0);
                    163: }
1.2       thorpej   164:
                    165: /* condition variables */
                    166:
1.23      christos  167: int __libc_cond_catchall_stub(cond_t *);
1.2       thorpej   168:
                    169: __weak_alias(__libc_cond_init,__libc_cond_init_stub)
                    170: __weak_alias(__libc_cond_signal,__libc_cond_catchall_stub)
                    171: __weak_alias(__libc_cond_broadcast,__libc_cond_catchall_stub)
1.25      joerg     172: __weak_alias(__libc_cond_wait,__libc_cond_catchall_stub)
1.2       thorpej   173: __weak_alias(__libc_cond_timedwait,__libc_cond_timedwait_stub)
                    174: __weak_alias(__libc_cond_destroy,__libc_cond_catchall_stub)
                    175:
1.23      christos  176: __strong_alias(__libc_cond_signal_stub,__libc_cond_catchall_stub)
                    177: __strong_alias(__libc_cond_broadcast_stub,__libc_cond_catchall_stub)
                    178: __strong_alias(__libc_cond_destroy_stub,__libc_cond_catchall_stub)
                    179:
1.2       thorpej   180: int
                    181: __libc_cond_init_stub(cond_t *c, const condattr_t *a)
                    182: {
                    183:        /* LINTED deliberate lack of effect */
                    184:        (void)c;
                    185:        /* LINTED deliberate lack of effect */
                    186:        (void)a;
                    187:
                    188:        CHECK_NOT_THREADED();
                    189:
                    190:        return (0);
                    191: }
                    192:
                    193: int
                    194: __libc_cond_wait_stub(cond_t *c, mutex_t *m)
                    195: {
                    196:        /* LINTED deliberate lack of effect */
                    197:        (void)c;
                    198:        /* LINTED deliberate lack of effect */
                    199:        (void)m;
                    200:
                    201:        CHECK_NOT_THREADED();
                    202:
                    203:        return (0);
                    204: }
                    205:
                    206: int
                    207: __libc_cond_timedwait_stub(cond_t *c, mutex_t *m, const struct timespec *t)
                    208: {
                    209:        /* LINTED deliberate lack of effect */
                    210:        (void)c;
                    211:        /* LINTED deliberate lack of effect */
                    212:        (void)m;
                    213:        /* LINTED deliberate lack of effect */
                    214:        (void)t;
                    215:
                    216:        CHECK_NOT_THREADED();
                    217:
                    218:        return (0);
                    219: }
                    220:
                    221: int
                    222: __libc_cond_catchall_stub(cond_t *c)
                    223: {
                    224:        /* LINTED deliberate lack of effect */
                    225:        (void)c;
                    226:
                    227:        CHECK_NOT_THREADED();
                    228:
                    229:        return (0);
                    230: }
                    231:
                    232:
                    233: /* read-write locks */
                    234:
1.23      christos  235: int __libc_rwlock_catchall_stub(rwlock_t *);
1.2       thorpej   236:
                    237: __weak_alias(__libc_rwlock_init,__libc_rwlock_init_stub)
                    238: __weak_alias(__libc_rwlock_rdlock,__libc_rwlock_catchall_stub)
                    239: __weak_alias(__libc_rwlock_wrlock,__libc_rwlock_catchall_stub)
                    240: __weak_alias(__libc_rwlock_tryrdlock,__libc_rwlock_catchall_stub)
                    241: __weak_alias(__libc_rwlock_trywrlock,__libc_rwlock_catchall_stub)
                    242: __weak_alias(__libc_rwlock_unlock,__libc_rwlock_catchall_stub)
                    243: __weak_alias(__libc_rwlock_destroy,__libc_rwlock_catchall_stub)
                    244:
1.23      christos  245: __strong_alias(__libc_rwlock_rdlock_stub,__libc_rwlock_catchall_stub)
                    246: __strong_alias(__libc_rwlock_wrlock_stub,__libc_rwlock_catchall_stub)
                    247: __strong_alias(__libc_rwlock_tryrdlock_stub,__libc_rwlock_catchall_stub)
                    248: __strong_alias(__libc_rwlock_trywrlock_stub,__libc_rwlock_catchall_stub)
                    249: __strong_alias(__libc_rwlock_unlock_stub,__libc_rwlock_catchall_stub)
                    250: __strong_alias(__libc_rwlock_destroy_stub,__libc_rwlock_catchall_stub)
                    251:
                    252:
1.2       thorpej   253: int
1.23      christos  254: __libc_rwlock_init_stub(rwlock_t *l, const rwlockattr_t *a)
1.2       thorpej   255: {
                    256:        /* LINTED deliberate lack of effect */
                    257:        (void)l;
                    258:        /* LINTED deliberate lack of effect */
                    259:        (void)a;
                    260:
                    261:        CHECK_NOT_THREADED();
                    262:
                    263:        return (0);
                    264: }
                    265:
                    266: int
                    267: __libc_rwlock_catchall_stub(rwlock_t *l)
                    268: {
                    269:        /* LINTED deliberate lack of effect */
                    270:        (void)l;
                    271:
                    272:        CHECK_NOT_THREADED();
                    273:
                    274:        return (0);
                    275: }
                    276:
                    277:
1.7       thorpej   278: /*
                    279:  * thread-specific data; we need to actually provide a simple TSD
                    280:  * implementation, since some thread-safe libraries want to use it.
                    281:  */
                    282:
                    283: #define        TSD_KEYS_MAX    64
                    284:
                    285: static struct {
                    286:        void *tsd_val;
                    287:        void (*tsd_dtor)(void *);
                    288:        int tsd_inuse;
                    289: } __libc_tsd[TSD_KEYS_MAX];
                    290: static int __libc_tsd_nextkey;
1.2       thorpej   291:
                    292: __weak_alias(__libc_thr_keycreate,__libc_thr_keycreate_stub)
                    293: __weak_alias(__libc_thr_setspecific,__libc_thr_setspecific_stub)
                    294: __weak_alias(__libc_thr_getspecific,__libc_thr_getspecific_stub)
                    295: __weak_alias(__libc_thr_keydelete,__libc_thr_keydelete_stub)
                    296:
                    297: int
                    298: __libc_thr_keycreate_stub(thread_key_t *k, void (*d)(void *))
                    299: {
1.7       thorpej   300:        int i;
1.2       thorpej   301:
1.7       thorpej   302:        for (i = __libc_tsd_nextkey; i < TSD_KEYS_MAX; i++) {
                    303:                if (__libc_tsd[i].tsd_inuse == 0)
                    304:                        goto out;
                    305:        }
                    306:
                    307:        for (i = 0; i < __libc_tsd_nextkey; i++) {
                    308:                if (__libc_tsd[i].tsd_inuse == 0)
                    309:                        goto out;
                    310:        }
                    311:
                    312:        return (EAGAIN);
                    313:
                    314:  out:
                    315:        /*
                    316:         * XXX We don't actually do anything with the destructor.  We
                    317:         * XXX probably should.
                    318:         */
                    319:        __libc_tsd[i].tsd_inuse = 1;
                    320:        __libc_tsd_nextkey = (i + i) % TSD_KEYS_MAX;
                    321:        __libc_tsd[i].tsd_dtor = d;
                    322:        *k = i;
1.2       thorpej   323:
                    324:        return (0);
                    325: }
                    326:
                    327: int
                    328: __libc_thr_setspecific_stub(thread_key_t k, const void *v)
                    329: {
                    330:
1.14      christos  331:        __libc_tsd[k].tsd_val = __UNCONST(v);
1.2       thorpej   332:
                    333:        return (0);
                    334: }
                    335:
                    336: void *
                    337: __libc_thr_getspecific_stub(thread_key_t k)
                    338: {
                    339:
1.7       thorpej   340:        return (__libc_tsd[k].tsd_val);
1.2       thorpej   341: }
                    342:
                    343: int
                    344: __libc_thr_keydelete_stub(thread_key_t k)
                    345: {
                    346:
1.7       thorpej   347:        /*
                    348:         * XXX Do not recycle key; see big comment in libpthread.
                    349:         */
                    350:
                    351:        __libc_tsd[k].tsd_dtor = NULL;
1.2       thorpej   352:
                    353:        return (0);
                    354: }
                    355:
                    356:
                    357: /* misc. */
                    358:
                    359: __weak_alias(__libc_thr_once,__libc_thr_once_stub)
                    360: __weak_alias(__libc_thr_sigsetmask,__libc_thr_sigsetmask_stub)
                    361: __weak_alias(__libc_thr_self,__libc_thr_self_stub)
1.5       thorpej   362: __weak_alias(__libc_thr_yield,__libc_thr_yield_stub)
                    363: __weak_alias(__libc_thr_create,__libc_thr_create_stub)
                    364: __weak_alias(__libc_thr_exit,__libc_thr_exit_stub)
1.9       nathanw   365: __weak_alias(__libc_thr_setcancelstate,__libc_thr_setcancelstate_stub)
1.16      drochner  366: __weak_alias(__libc_thr_equal,__libc_thr_equal_stub)
1.18      christos  367: __weak_alias(__libc_thr_curcpu,__libc_thr_curcpu_stub)
1.2       thorpej   368:
1.5       thorpej   369:
1.2       thorpej   370: int
                    371: __libc_thr_once_stub(once_t *o, void (*r)(void))
                    372: {
                    373:
1.3       thorpej   374:        /* XXX Knowledge of libpthread types. */
                    375:
                    376:        if (o->pto_done == 0) {
                    377:                (*r)();
                    378:                o->pto_done = 1;
                    379:        }
1.2       thorpej   380:
                    381:        return (0);
                    382: }
                    383:
                    384: int
                    385: __libc_thr_sigsetmask_stub(int h, const sigset_t *s, sigset_t *o)
                    386: {
                    387:
                    388:        CHECK_NOT_THREADED();
                    389:
1.10      nathanw   390:        return sigprocmask(h, s, o);
1.2       thorpej   391: }
                    392:
                    393: thr_t
                    394: __libc_thr_self_stub(void)
                    395: {
                    396:
1.6       thorpej   397:        return ((thr_t) -1);
1.5       thorpej   398: }
                    399:
1.11      nathanw   400: int
1.5       thorpej   401: __libc_thr_yield_stub(void)
                    402: {
                    403:
                    404:        /* Nothing to do. */
1.11      nathanw   405:        return (0);
1.5       thorpej   406: }
                    407:
                    408: int
                    409: __libc_thr_create_stub(thr_t *tp, const thrattr_t *ta,
                    410:     void *(*f)(void *), void *a)
                    411: {
                    412:        /* LINTED deliberate lack of effect */
                    413:        (void)tp;
                    414:        /* LINTED deliberate lack of effect */
                    415:        (void)ta;
                    416:        /* LINTED deliberate lack of effect */
                    417:        (void)f;
                    418:        /* LINTED deliberate lack of effect */
                    419:        (void)a;
                    420:
1.2       thorpej   421:        DIE();
                    422:
1.5       thorpej   423:        return (EOPNOTSUPP);
                    424: }
                    425:
1.27      christos  426: __dead void
1.5       thorpej   427: __libc_thr_exit_stub(void *v)
                    428: {
                    429:        /* LINTED deliberate lack of effect */
                    430:        (void)v;
                    431:        exit(0);
1.9       nathanw   432: }
                    433:
                    434: int
                    435: __libc_thr_setcancelstate_stub(int new, int *old)
                    436: {
                    437:        /* LINTED deliberate lack of effect */
                    438:        (void)new;
                    439:
                    440:        /* LINTED deliberate lack of effect */
                    441:        (void)old;
                    442:
                    443:        CHECK_NOT_THREADED();
                    444:
                    445:        return (0);
1.2       thorpej   446: }
                    447:
1.16      drochner  448: int
                    449: __libc_thr_equal_stub(pthread_t t1, pthread_t t2)
                    450: {
                    451:
                    452:        /* assert that t1=t2=pthread_self() */
                    453:        return (t1 == t2);
                    454: }
                    455:
1.17      ad        456: unsigned int
1.18      christos  457: __libc_thr_curcpu_stub(void)
1.17      ad        458: {
                    459:
                    460:        return (0);
                    461: }
                    462:
1.2       thorpej   463: #endif /* _REENTRANT */

CVSweb <webmaster@jp.NetBSD.org>