lib/libpthread/pthread_int.h

   1 /*      $NetBSD: pthread_int.h,v 1.71 2009/05/16 22:21:18 ad Exp $      */
   2
   3 /*-
   4  * Copyright (c) 2001, 2002, 2003, 2006, 2007, 2008 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Nathan J. Williams and Andrew Doran.
   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
  32 /*
  33  * NOTE: when changing anything in this file, please ensure that
  34  * libpthread_dbg still compiles.
  35  */
  36
  37 #ifndef _LIB_PTHREAD_INT_H
  38 #define _LIB_PTHREAD_INT_H
  39
  40 /* #define PTHREAD__DEBUG */
  41 #define ERRORCHECK
  42
  43 #include "pthread_types.h"
  44 #include "pthread_queue.h"
  45 #include "pthread_md.h"
  46
  47 /* Need to use libc-private names for atomic operations. */
  48 #include "../../common/lib/libc/atomic/atomic_op_namespace.h"
  49
  50 #include <sys/atomic.h>
  51 #include <sys/tree.h>
  52
  53 #include <lwp.h>
  54 #include <signal.h>
  55
  56 #ifdef __GNUC__
  57 #define PTHREAD_HIDE    __attribute__ ((visibility("hidden")))
  58 #else
  59 #define PTHREAD_HIDE    /* nothing */
  60 #endif
  61
  62 #define PTHREAD_KEYS_MAX        256
  63 #define PTHREAD__UNPARK_MAX     32
  64
  65 /*
  66  * The size of this structure needs to be no larger than struct
  67  * __pthread_cleanup_store, defined in pthread.h.
  68  */
  69 struct pt_clean_t {
  70         PTQ_ENTRY(pt_clean_t)   ptc_next;
  71         void    (*ptc_cleanup)(void *);
  72         void    *ptc_arg;
  73 };
  74
  75 /* Private data for pthread_attr_t */
  76 struct pthread_attr_private {
  77         char ptap_name[PTHREAD_MAX_NAMELEN_NP];
  78         void *ptap_namearg;
  79         void *ptap_stackaddr;
  80         size_t ptap_stacksize;
  81         size_t ptap_guardsize;
  82         struct sched_param ptap_sp;
  83         int ptap_policy;
  84 };
  85
  86 struct pthread_lock_ops {
  87         void    (*plo_init)(__cpu_simple_lock_t *);
  88         int     (*plo_try)(__cpu_simple_lock_t *);
  89         void    (*plo_unlock)(__cpu_simple_lock_t *);
  90         void    (*plo_lock)(__cpu_simple_lock_t *);
  91 };
  92
  93 struct  __pthread_st {
  94         pthread_t       pt_self;        /* Must be first. */
  95         unsigned int    pt_magic;       /* Magic number */
  96         int             pt_state;       /* running, blocked, etc. */
  97         pthread_mutex_t pt_lock;        /* lock on state */
  98         int             pt_flags;       /* see PT_FLAG_* below */
  99         int             pt_cancel;      /* Deferred cancellation */
 100         int             pt_errno;       /* Thread-specific errno. */
 101         stack_t         pt_stack;       /* Our stack */
 102         void            *pt_exitval;    /* Read by pthread_join() */
 103         char            *pt_name;       /* Thread's name, set by the app. */
 104         int             pt_willpark;    /* About to park */
 105         lwpid_t         pt_unpark;      /* Unpark this when parking */
 106         struct pthread_lock_ops pt_lockops;/* Cached to avoid PIC overhead */
 107         pthread_mutex_t *pt_droplock;   /* Drop this lock if cancelled */
 108         pthread_cond_t  pt_joiners;     /* Threads waiting to join. */
 109         void            *(*pt_func)(void *);/* Function to call at start. */
 110         void            *pt_arg;        /* Argumen to pass at start. */
 111
 112         /* Threads to defer waking, usually until pthread_mutex_unlock(). */
 113         lwpid_t         pt_waiters[PTHREAD__UNPARK_MAX];
 114         size_t          pt_nwaiters;
 115
 116         /* Stack of cancellation cleanup handlers and their arguments */
 117         PTQ_HEAD(, pt_clean_t)  pt_cleanup_stack;
 118
 119         /* LWP ID and entry on the list of all threads. */
 120         lwpid_t         pt_lid;
 121         RB_ENTRY(__pthread_st) pt_alltree;
 122         PTQ_ENTRY(__pthread_st) pt_allq;
 123         PTQ_ENTRY(__pthread_st) pt_deadq;
 124
 125         /*
 126          * General synchronization data.  We try to align, as threads
 127          * on other CPUs will access this data frequently.
 128          */
 129         int             pt_dummy1 __aligned(128);
 130         struct lwpctl   *pt_lwpctl;     /* Kernel/user comms area */
 131         volatile int    pt_blocking;    /* Blocking in userspace */
 132         volatile int    pt_rwlocked;    /* Handed rwlock successfully */
 133         volatile int    pt_signalled;   /* Received pthread_cond_signal() */
 134         volatile int    pt_mutexwait;   /* Waiting to acquire mutex */
 135         void * volatile pt_mutexnext;   /* Next thread in chain */
 136         void * volatile pt_sleepobj;    /* Object slept on */
 137         PTQ_ENTRY(__pthread_st) pt_sleep;
 138         void            (*pt_early)(void *);
 139         int             pt_dummy2 __aligned(128);
 140
 141         /* Thread-specific data.  Large so it sits close to the end. */
 142         int             pt_havespecific;
 143         void            *pt_specific[PTHREAD_KEYS_MAX];
 144
 145         /*
 146          * Context for thread creation.  At the end as it's cached
 147          * and then only ever passed to _lwp_create().
 148          */
 149         ucontext_t      pt_uc;
 150 };
 151
 152 /* Thread states */
 153 #define PT_STATE_RUNNING        1
 154 #define PT_STATE_ZOMBIE         5
 155 #define PT_STATE_DEAD           6
 156
 157 /* Flag values */
 158
 159 #define PT_FLAG_DETACHED        0x0001
 160 #define PT_FLAG_CS_DISABLED     0x0004  /* Cancellation disabled */
 161 #define PT_FLAG_CS_ASYNC        0x0008  /* Cancellation is async */
 162 #define PT_FLAG_CS_PENDING      0x0010
 163 #define PT_FLAG_SCOPE_SYSTEM    0x0040
 164 #define PT_FLAG_EXPLICIT_SCHED  0x0080
 165 #define PT_FLAG_SUSPENDED       0x0100  /* In the suspended queue */
 166
 167 #define PT_MAGIC        0x11110001
 168 #define PT_DEAD         0xDEAD0001
 169
 170 #define PT_ATTR_MAGIC   0x22220002
 171 #define PT_ATTR_DEAD    0xDEAD0002
 172
 173 extern int      pthread__stacksize_lg;
 174 extern size_t   pthread__stacksize;
 175 extern vaddr_t  pthread__stackmask;
 176 extern vaddr_t  pthread__threadmask;
 177 extern int      pthread__nspins;
 178 extern int      pthread__concurrency;
 179 extern int      pthread__osrev;
 180 extern int      pthread__unpark_max;
 181
 182 /* Flag to be used in a ucontext_t's uc_flags indicating that
 183  * the saved register state is "user" state only, not full
 184  * trap state.
 185  */
 186 #define _UC_USER_BIT            30
 187 #define _UC_USER                (1LU << _UC_USER_BIT)
 188
 189 /* Utility functions */
 190 void    pthread__unpark_all(pthread_queue_t *, pthread_t, pthread_mutex_t *)
 191     PTHREAD_HIDE;
 192 void    pthread__unpark(pthread_queue_t *, pthread_t, pthread_mutex_t *)
 193     PTHREAD_HIDE;
 194 int     pthread__park(pthread_t, pthread_mutex_t *, pthread_queue_t *,
 195                       const struct timespec *, int, const void *)
 196                       PTHREAD_HIDE;
 197 pthread_mutex_t *pthread__hashlock(volatile const void *) PTHREAD_HIDE;
 198
 199 /* Internal locking primitives */
 200 void    pthread__lockprim_init(void) PTHREAD_HIDE;
 201 void    pthread_lockinit(pthread_spin_t *) PTHREAD_HIDE;
 202
 203 static inline void pthread__spinlock(pthread_t, pthread_spin_t *)
 204     __attribute__((__always_inline__));
 205 static inline void
 206 pthread__spinlock(pthread_t self, pthread_spin_t *lock)
 207 {
 208         if (__predict_true((*self->pt_lockops.plo_try)(lock)))
 209                 return;
 210         (*self->pt_lockops.plo_lock)(lock);
 211 }
 212
 213 static inline int pthread__spintrylock(pthread_t, pthread_spin_t *)
 214     __attribute__((__always_inline__));
 215 static inline int
 216 pthread__spintrylock(pthread_t self, pthread_spin_t *lock)
 217 {
 218         return (*self->pt_lockops.plo_try)(lock);
 219 }
 220
 221 static inline void pthread__spinunlock(pthread_t, pthread_spin_t *)
 222     __attribute__((__always_inline__));
 223 static inline void
 224 pthread__spinunlock(pthread_t self, pthread_spin_t *lock)
 225 {
 226         (*self->pt_lockops.plo_unlock)(lock);
 227 }
 228
 229 extern const struct pthread_lock_ops *pthread__lock_ops;
 230
 231 int     pthread__simple_locked_p(__cpu_simple_lock_t *) PTHREAD_HIDE;
 232 #define pthread__simple_lock_init(alp)  (*pthread__lock_ops->plo_init)(alp)
 233 #define pthread__simple_lock_try(alp)   (*pthread__lock_ops->plo_try)(alp)
 234 #define pthread__simple_unlock(alp)     (*pthread__lock_ops->plo_unlock)(alp)
 235
 236 void    pthread__testcancel(pthread_t) PTHREAD_HIDE;
 237 int     pthread__find(pthread_t) PTHREAD_HIDE;
 238
 239 #ifndef PTHREAD_MD_INIT
 240 #define PTHREAD_MD_INIT
 241 #endif
 242
 243 #ifndef _INITCONTEXT_U_MD
 244 #define _INITCONTEXT_U_MD(ucp)
 245 #endif
 246
 247 #define _INITCONTEXT_U(ucp) do {                                        \
 248         (ucp)->uc_flags = _UC_CPU | _UC_STACK;                          \
 249         _INITCONTEXT_U_MD(ucp)                                          \
 250         } while (/*CONSTCOND*/0)
 251
 252 /* Stack location of pointer to a particular thread */
 253 #define pthread__id(sp) \
 254         ((pthread_t) (((vaddr_t)(sp)) & pthread__threadmask))
 255
 256 #ifdef PTHREAD__HAVE_THREADREG
 257 #define pthread__self()         pthread__threadreg_get()
 258 #else
 259 #define pthread__self()         (pthread__id(pthread__sp()))
 260 #endif
 261
 262 #define pthread__abort()                                                \
 263         pthread__assertfunc(__FILE__, __LINE__, __func__, "unreachable")
 264
 265 #define pthread__assert(e) do {                                         \
 266         if (__predict_false(!(e)))                                      \
 267                pthread__assertfunc(__FILE__, __LINE__, __func__, #e);   \
 268         } while (/*CONSTCOND*/0)
 269
 270 #define pthread__error(err, msg, e) do {                                \
 271         if (__predict_false(!(e))) {                                    \
 272                pthread__errorfunc(__FILE__, __LINE__, __func__, msg);   \
 273                return (err);                                            \
 274         }                                                               \
 275         } while (/*CONSTCOND*/0)
 276
 277 void    pthread__destroy_tsd(pthread_t) PTHREAD_HIDE;
 278 void    pthread__assertfunc(const char *, int, const char *, const char *)
 279                             PTHREAD_HIDE;
 280 void    pthread__errorfunc(const char *, int, const char *, const char *)
 281                            PTHREAD_HIDE;
 282 char    *pthread__getenv(const char *) PTHREAD_HIDE;
 283 void    pthread__cancelled(void) PTHREAD_HIDE;
 284 void    pthread__mutex_deferwake(pthread_t, pthread_mutex_t *) PTHREAD_HIDE;
 285 int     pthread__checkpri(int) PTHREAD_HIDE;
 286
 287 #ifndef pthread__smt_pause
 288 #define pthread__smt_pause()    /* nothing */
 289 #endif
 290
 291 /*
 292  * Bits in the owner field of the lock that indicate lock state.  If the
 293  * WRITE_LOCKED bit is clear, then the owner field is actually a count of
 294  * the number of readers.
 295  */
 296 #define RW_HAS_WAITERS          0x01    /* lock has waiters */
 297 #define RW_WRITE_WANTED         0x02    /* >= 1 waiter is a writer */
 298 #define RW_WRITE_LOCKED         0x04    /* lock is currently write locked */
 299 #define RW_UNUSED               0x08    /* currently unused */
 300
 301 #define RW_FLAGMASK             0x0f
 302
 303 #define RW_READ_COUNT_SHIFT     4
 304 #define RW_READ_INCR            (1 << RW_READ_COUNT_SHIFT)
 305 #define RW_THREAD               ((uintptr_t)-RW_READ_INCR)
 306 #define RW_OWNER(rw)            ((rw)->rw_owner & RW_THREAD)
 307 #define RW_COUNT(rw)            ((rw)->rw_owner & RW_THREAD)
 308 #define RW_FLAGS(rw)            ((rw)->rw_owner & ~RW_THREAD)
 309
 310 #endif /* _LIB_PTHREAD_INT_H */