Rename *_priv.* to *P.*
[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 <synchP.h>
78 #include <synch.h>
79 #include <schedP.h>
80
81 /* These are the result of the macro expansion of INTERNAL_SYSCALL.  */
82
83 /* XXX: These are really gross and should die.  */
84
85 static inline int __internal_kill_1 (int *errval, int sig)
86 {
87   sysret_t ret;
88   *errval = __systemcall (&ret, SYS_kill, sig);
89   return ret.sys_rval1;
90 }
91
92 static inline pthread_t __internal_set_tid_address_1 (int *errval, pthread_t *tid)
93 {
94   sysret_t ret;
95   *errval = __systemcall (&ret, SYS_lwp_self);
96   return *tid = ret.sys_rval1;
97 }
98
99 static inline int __internal_rt_sigprocmask_4 (int *errval, int how,
100     const sigset_t *set, sigset_t *oldset, int setsize)
101 {
102   int saved_errno = errno;
103   int result = sigprocmask (how, set, oldset);
104   if (result != 0)
105     *errval = errno;
106   __set_errno (saved_errno);
107   return result;
108 }
109
110 static inline int __internal_write_3 (int *errval, int fd, const void *buf,
111     size_t count)
112 {
113   sysret_t ret;
114   *errval = __systemcall (&ret, SYS_write, fd, buf, count);
115   return ret.sys_rval1;
116 }
117
118 static inline int __internal_tkill_2 (int *errval, pthread_t tid, int sig)
119 {
120   sysret_t ret;
121   *errval = __systemcall (&ret, SYS_lwp_kill, tid, sig);
122   return ret.sys_rval1;
123 }
124
125 static inline int __internal_pause_1 (int *errval, int unused)
126 {
127   sysret_t ret;
128   *errval = __systemcall (&ret, SYS_pause);
129   return ret.sys_rval1;
130 }
131
132 static inline int __internal_nanosleep_2 (int *errval,
133     const struct timespec *req, struct timespec *rem)
134 {
135   sysret_t ret;
136   *errval = __systemcall (&ret, SYS_nanosleep, req, rem);
137   return ret.sys_rval1;
138 }
139
140 static inline int __internal_sched_get_priority_min_1 (int *errval, int policy)
141 {
142   int saved_errno = errno;
143   int result = sched_get_priority_min (policy);
144   if (result != 0)
145     *errval = errno;
146   __set_errno (saved_errno);
147   return result;
148 }
149
150 static inline int __internal_sched_get_priority_max_1 (int *errval, int policy)
151 {
152   int saved_errno = errno;
153   int result = sched_get_priority_max (policy);
154   if (result != 0)
155     *errval = errno;
156   __set_errno (saved_errno);
157   return result;
158 }
159
160 /* These are used by the "real" associated functions.  */
161
162 static inline int __pthread_setschedparam_internal (pthread_t threadid,
163     int policy, const struct sched_param *param)
164 {
165   return __sched_setscheduler_id (P_LWPID, threadid, policy,
166       param->__sched_priority);
167 }
168
169 static inline int __pthread_setschedprio_internal (pthread_t threadid,
170     int prio)
171 {
172   return __sched_setparam_id (P_LWPID, threadid, prio);
173 }
174
175 static inline int __pthread_getschedparam_internal (pthread_t threadid,
176     int *policy, struct sched_param *param)
177 {
178   return __sched_getscheduler_id (P_LWPID, threadid, policy,
179       &param->__sched_priority);
180 }
181
182 static inline int __cond_has_waiters (pthread_cond_t *cond)
183 {
184   return cond->cond_waiters_kernel;
185 }
186
187 /* These functions are used to implement the "real" associated functions.  */
188 extern int __cond_reltimedwait_internal (cond_t *cond, mutex_t *mutex,
189     struct timespec *reltime, int cancel);
190 extern int __mutex_timedlock (mutex_t *mutex, const struct timespec *abstime);
191 extern int __rw_timedrdlock (rwlock_t *rwlock, struct timespec *abstime);
192 extern int __rw_timedwrlock (rwlock_t *rwlock, struct timespec *abstime);
193 extern int __sema_timedwait (sema_t *sem, struct timespec *abstime);
194
195 #endif /* _OPENSOLARIS_PTHREADP_H */