15258d86e490f1a6025d89401c71269659d9431c
[kopensolaris-gnu/glibc.git] / nptl / sysdeps / unix / sysv / solaris2 / kopensolaris-gnu / pthreadP.h
1 /* Copyright (C) 2008 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by David Bartley <dtbartle@csclub.uwaterloo.ca>, 2008.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #ifndef _OPENSOLARIS_PTHREADP_H
21 #define _OPENSOLARIS_PTHREADP_H
22
23 /* It is known that the first lwpid is 1.  */
24 #define FIRST_THREAD_TID        1
25
26 /* rwlock macros.  */
27 #define _RWLOCK_WR_LOCK         0x80000000
28 #define _RWLOCK_RD_MASK         0x7FFFFFFF
29 #define _RWLOCK_RD_MAX      0x7FFFFFFF
30
31 #include <nptl/pthreadP.h>
32 #include <sys/synch.h>
33
34 /* Flags in mutex attr.  */
35 #undef PTHREAD_MUTEXATTR_PROTOCOL_SHIFT
36 #define PTHREAD_MUTEXATTR_PROTOCOL_SHIFT        0
37 #undef PTHREAD_MUTEXATTR_PROTOCOL_MASK
38 #define PTHREAD_MUTEXATTR_PROTOCOL_MASK \
39   (PTHREAD_PRIO_INHERIT | PTHREAD_PRIO_PROTECT)
40 #undef PTHREAD_MUTEXATTR_PRIO_CEILING_SHIFT
41 #define PTHREAD_MUTEXATTR_PRIO_CEILING_SHIFT    12
42 #undef PTHREAD_MUTEXATTR_PRIO_CEILING_MASK
43 #define PTHREAD_MUTEXATTR_PRIO_CEILING_MASK     0x0ffff000
44 #undef PTHREAD_MUTEXATTR_FLAG_ROBUST
45 #define PTHREAD_MUTEXATTR_FLAG_ROBUST           LOCK_ROBUST
46 #undef PTHREAD_MUTEXATTR_FLAG_PSHARED
47 #define PTHREAD_MUTEXATTR_FLAG_PSHARED          LOCK_SHARED
48 #undef PTHREAD_MUTEXATTR_FLAG_BITS
49 #define PTHREAD_MUTEXATTR_FLAG_BITS \
50   (PTHREAD_MUTEXATTR_FLAG_ROBUST | PTHREAD_MUTEXATTR_FLAG_PSHARED \
51    | PTHREAD_MUTEXATTR_PROTOCOL_MASK | PTHREAD_MUTEXATTR_PRIO_CEILING_MASK)
52
53 #define PTHREAD_RWLOCK_TYPE_MASK    0x00000006
54 #define PTHREAD_RWLOCK_TYPE_SHIFT   1
55 #undef PTHREAD_RWLOCK_PREFER_READER_P
56 #define PTHREAD_RWLOCK_PREFER_READER_P(rwlock) \
57     (((rwlock->type >> PTHREAD_RWLOCK_TYPE_SHIFT) & \
58     PTHREAD_RWLOCK_TYPE_MASK) != PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP)
59
60 #define MUTEX_IS_OWNER(mutex) \
61        (mutex->mutex_lockbyte == LOCKBYTE_SET &&                        \
62      (((mutex)->mutex_type & LOCK_SHARED) == 0 ||                       \
63       (mutex)->mutex_ownerpid == THREAD_GETMEM (THREAD_SELF, pid)) &&   \
64      ((mutex)->mutex_owner == THREAD_GETMEM (THREAD_SELF, tid)))
65
66 #define MUTEX_NOT_OWNER(mutex)  (! MUTEX_IS_OWNER (mutex))
67
68 #define INVALID_TIMESPEC(tv)    ((tv) && ((tv)->tv_sec < 0 || \
69     (tv)->tv_nsec < 0 || (tv)->tv_nsec >= 1000000000))
70
71 #include <sys/types.h>
72 #include <sys/syscall.h>
73 #include <signal.h>
74 #include <unistd.h>
75 #include <errno.h>
76 #include <inline-syscall.h>
77 #include <synch_priv.h>
78 #include <synch.h>
79
80 /* These are the result of the macro expansion of INTERNAL_SYSCALL.  */
81
82 /* XXX: These are really gross and should die.  */
83
84 static inline int __internal_kill_1 (int *errval, int sig)
85 {
86   sysret_t ret;
87   *errval = __systemcall (&ret, SYS_kill, sig);
88   return ret.sys_rval1;
89 }
90
91 static inline pthread_t __internal_set_tid_address_1 (int *errval, pthread_t *tid)
92 {
93   sysret_t ret;
94   *errval = __systemcall (&ret, SYS_lwp_self);
95   return *tid = ret.sys_rval1;
96 }
97
98 static inline int __internal_rt_sigprocmask_4 (int *errval, int how,
99     const sigset_t *set, sigset_t *oldset, int setsize)
100 {
101   int saved_errno = errno;
102   int result = sigprocmask (how, set, oldset);
103   if (result != 0)
104     *errval = errno;
105   __set_errno (saved_errno);
106   return result;
107 }
108
109 static inline int __internal_write_3 (int *errval, int fd, const void *buf,
110     size_t count)
111 {
112   sysret_t ret;
113   *errval = __systemcall (&ret, SYS_write, fd, buf, count);
114   return ret.sys_rval1;
115 }
116
117 static inline int __internal_tkill_2 (int *errval, pthread_t tid, int sig)
118 {
119   sysret_t ret;
120   *errval = __systemcall (&ret, SYS_lwp_kill, tid, sig);
121   return ret.sys_rval1;
122 }
123
124 static inline int __internal_pause_1 (int *errval, int unused)
125 {
126   sysret_t ret;
127   *errval = __systemcall (&ret, SYS_pause);
128   return ret.sys_rval1;
129 }
130
131 static inline int __internal_nanosleep_2 (int *errval,
132     const struct timespec *req, struct timespec *rem)
133 {
134   sysret_t ret;
135   *errval = __systemcall (&ret, SYS_nanosleep, req, rem);
136   return ret.sys_rval1;
137 }
138
139 static inline int __internal_sched_get_priority_min_1 (int *errval, int policy)
140 {
141   int saved_errno = errno;
142   int result = sched_get_priority_min (policy);
143   if (result != 0)
144     *errval = errno;
145   __set_errno (saved_errno);
146   return result;
147 }
148
149 static inline int __internal_sched_get_priority_max_1 (int *errval, int policy)
150 {
151   int saved_errno = errno;
152   int result = sched_get_priority_max (policy);
153   if (result != 0)
154     *errval = errno;
155   __set_errno (saved_errno);
156   return result;
157 }
158
159 /* These are used by the "real" associated functions.  */
160
161 #include <sched_priv.h>
162
163 static inline int __pthread_setschedparam_internal (pthread_t threadid,
164     int policy, const struct sched_param *param)
165 {
166   return __sched_setscheduler_id (P_LWPID, threadid, policy,
167       param->__sched_priority);
168 }
169
170 static inline int __pthread_setschedprio_internal (pthread_t threadid,
171     int prio)
172 {
173   return __sched_setparam_id (P_LWPID, threadid, prio);
174 }
175
176 static inline int __pthread_getschedparam_internal (pthread_t threadid,
177     int *policy, struct sched_param *param)
178 {
179   return __sched_getscheduler_id (P_LWPID, threadid, policy,
180       &param->__sched_priority);
181 }
182
183 static inline int __cond_has_waiters (pthread_cond_t *cond)
184 {
185   return cond->cond_waiters_kernel;
186 }
187
188 /* These functions are used to implement the "real" associated functions.  */
189 extern int __cond_reltimedwait_internal (cond_t *cond, mutex_t *mutex,
190     struct timespec *reltime, int cancel);
191 extern int __mutex_timedlock (mutex_t *mutex, const struct timespec *abstime);
192 extern int __rw_timedrdlock (rwlock_t *rwlock, struct timespec *abstime);
193 extern int __rw_timedwrlock (rwlock_t *rwlock, struct timespec *abstime);
194 extern int __sema_timedwait (sema_t *sem, struct timespec *abstime);
195
196 #endif /* _OPENSOLARIS_PTHREADP_H */