1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
/* Declarations of internal pthread functions used by libc. Hurd version.
Copyright (C) 2016-2025 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#ifndef _PTHREADP_H
#define _PTHREADP_H 1
#define __PTHREAD_HTL
#include <pthread.h>
#include <link.h>
/* Attribute to indicate thread creation was issued from C11 thrd_create. */
#define ATTR_C11_THREAD ((void*)(uintptr_t)-1)
extern void __pthread_init_static_tls (struct link_map *) attribute_hidden;
/* These represent the interface used by glibc itself. */
extern int __pthread_mutex_init (pthread_mutex_t *__mutex, const pthread_mutexattr_t *__attr);
extern int __pthread_mutex_destroy (pthread_mutex_t *__mutex);
extern int __pthread_mutex_lock (pthread_mutex_t *__mutex);
extern int __pthread_mutex_trylock (pthread_mutex_t *_mutex);
extern int __pthread_mutex_timedlock (pthread_mutex_t *__mutex,
const struct timespec *__abstime);
extern int __pthread_mutex_unlock (pthread_mutex_t *__mutex);
extern int __pthread_mutexattr_settype (pthread_mutexattr_t *attr, int kind);
extern int __pthread_mutexattr_getpshared(const pthread_mutexattr_t *__restrict __attr,
int *__restrict __pshared);
libc_hidden_proto (__pthread_mutexattr_getpshared)
extern int __pthread_mutexattr_setpshared(pthread_mutexattr_t *__attr,
int __pshared);
libc_hidden_proto (__pthread_mutexattr_setpshared)
/* Get the robustness flag of the mutex attribute ATTR. */
extern int __pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
int *__robustness);
libc_hidden_proto (__pthread_mutexattr_getrobust)
extern int __pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
int *__robustness);
libc_hidden_proto (__pthread_mutexattr_getrobust_np)
extern int __pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
int __robustness);
libc_hidden_proto (__pthread_mutexattr_setrobust_np)
/* Set the robustness flag of the mutex attribute ATTR. */
extern int __pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
int __robustness);
libc_hidden_proto (__pthread_mutexattr_setrobust)
extern int __pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *__restrict __attr,
int *__restrict __prioceiling);
libc_hidden_proto (__pthread_mutexattr_getprioceiling)
extern int __pthread_mutexattr_setprioceiling(pthread_mutexattr_t *__attr,
int __prioceiling);
libc_hidden_proto (__pthread_mutexattr_setprioceiling)
extern int __pthread_mutexattr_getprotocol(const pthread_mutexattr_t *__restrict __attr,
int *__restrict __protocol);
libc_hidden_proto (__pthread_mutexattr_getprotocol)
extern int __pthread_mutexattr_setprotocol(pthread_mutexattr_t *__attr,
int __protocol);
libc_hidden_proto (__pthread_mutexattr_setprotocol)
extern int __pthread_mutexattr_gettype(const pthread_mutexattr_t *__restrict __attr,
int *__restrict __type);
libc_hidden_proto (__pthread_mutexattr_gettype)
extern int __pthread_mutexattr_settype(pthread_mutexattr_t *__attr,
int __type);
libc_hidden_proto (__pthread_mutexattr_settype)
extern int __pthread_cond_init (pthread_cond_t *cond,
const pthread_condattr_t *cond_attr);
libc_hidden_proto (__pthread_cond_init)
extern int __pthread_cond_signal (pthread_cond_t *cond);
libc_hidden_proto (__pthread_cond_signal);
extern int __pthread_cond_broadcast (pthread_cond_t *cond);
libc_hidden_proto (__pthread_cond_broadcast);
extern int __pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex);
libc_hidden_proto (__pthread_cond_wait);
extern int __pthread_cond_timedwait (pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *abstime);
libc_hidden_proto (__pthread_cond_timedwait);
extern int __pthread_cond_clockwait (pthread_cond_t *cond,
pthread_mutex_t *mutex,
clockid_t clockid,
const struct timespec *abstime)
__nonnull ((1, 2, 4));
libc_hidden_proto (__pthread_cond_clockwait);
extern int __pthread_cond_destroy (pthread_cond_t *cond);
libc_hidden_proto (__pthread_cond_destroy);
extern int __pthread_sigmask (int, const sigset_t *, sigset_t *);
libc_hidden_proto (__pthread_sigmask);
typedef struct __cthread *__cthread_t;
typedef int __cthread_key_t;
typedef void * (*__cthread_fn_t)(void *__arg);
__cthread_t __cthread_fork (__cthread_fn_t, void *);
int __pthread_create (pthread_t *newthread,
const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
void __cthread_detach (__cthread_t);
int __pthread_detach (pthread_t __threadp);
void __pthread_exit (void *value) __attribute__ ((__noreturn__));
int __pthread_join (pthread_t, void **);
int __cthread_keycreate (__cthread_key_t *);
int __cthread_getspecific (__cthread_key_t, void **);
int __cthread_setspecific (__cthread_key_t, void *);
int __pthread_key_create (pthread_key_t *key, void (*destr) (void *));
void *__pthread_getspecific (pthread_key_t key);
int __pthread_setspecific (pthread_key_t key, const void *value);
int __pthread_key_delete (pthread_key_t key);
int __pthread_once (pthread_once_t *once_control, void (*init_routine) (void));
int __pthread_setcancelstate (int state, int *oldstate);
int __pthread_getattr_np (pthread_t, pthread_attr_t *);
int __pthread_attr_getstackaddr (const pthread_attr_t *__restrict __attr,
void **__restrict __stackaddr);
libc_hidden_proto (__pthread_attr_getstackaddr)
int __pthread_attr_setstackaddr (pthread_attr_t *__attr, void *__stackaddr);
libc_hidden_proto (__pthread_attr_setstackaddr)
int __pthread_attr_getstacksize (const pthread_attr_t *__restrict __attr,
size_t *__restrict __stacksize);
libc_hidden_proto (__pthread_attr_getstacksize)
int __pthread_attr_setstacksize (pthread_attr_t *__attr, size_t __stacksize);
libc_hidden_proto (__pthread_attr_setstacksize)
int __pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
size_t __stacksize);
libc_hidden_proto (__pthread_attr_setstack)
int __pthread_attr_getstack (const pthread_attr_t *, void **, size_t *);
libc_hidden_proto (__pthread_attr_getstack)
void __pthread_testcancel (void);
int __pthread_attr_init (pthread_attr_t *attr);
int __pthread_condattr_init (pthread_condattr_t *attr);
#define __pthread_raise_internal(__sig) raise (__sig)
libc_hidden_proto (__pthread_self)
libc_hidden_proto (__pthread_attr_init)
libc_hidden_proto (__pthread_condattr_init)
#if IS_IN (libpthread)
hidden_proto (__pthread_create)
hidden_proto (__pthread_detach)
hidden_proto (__pthread_key_create)
hidden_proto (__pthread_getspecific)
hidden_proto (__pthread_setspecific)
hidden_proto (__pthread_mutex_init)
hidden_proto (__pthread_mutex_destroy)
hidden_proto (__pthread_mutex_lock)
hidden_proto (__pthread_mutex_trylock)
hidden_proto (__pthread_mutex_unlock)
hidden_proto (__pthread_mutex_timedlock)
hidden_proto (__pthread_get_cleanup_stack)
#endif
#if !defined(__NO_WEAK_PTHREAD_ALIASES) && !IS_IN (libpthread)
# ifdef weak_extern
weak_extern (__pthread_exit)
# else
# pragma weak __pthread_exit
# endif
#endif
#define ASSERT_TYPE_SIZE(type, size) \
_Static_assert (sizeof (type) == size, \
"sizeof (" #type ") != " #size)
#endif /* pthreadP.h */
|
