forked from zephyrproject-rtos/zephyr
-
Notifications
You must be signed in to change notification settings - Fork 0
/
pthread.h
553 lines (480 loc) · 15 KB
/
pthread.h
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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
/*
* Copyright (c) 2017 Intel Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef ZEPHYR_INCLUDE_POSIX_PTHREAD_H_
#define ZEPHYR_INCLUDE_POSIX_PTHREAD_H_
#include <stdlib.h>
#include <string.h>
#include <zephyr/kernel.h>
#include <zephyr/posix/time.h>
#include <zephyr/posix/unistd.h>
#include <zephyr/posix/sched.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* Pthread detach/joinable
* Undefine possibly predefined values by external toolchain headers
*/
#undef PTHREAD_CREATE_DETACHED
#define PTHREAD_CREATE_DETACHED 1
#undef PTHREAD_CREATE_JOINABLE
#define PTHREAD_CREATE_JOINABLE 0
/* Pthread resource visibility */
#define PTHREAD_PROCESS_PRIVATE 0
#define PTHREAD_PROCESS_SHARED 1
/* Pthread cancellation */
#define PTHREAD_CANCELED ((void *)-1)
#define PTHREAD_CANCEL_ENABLE 0
#define PTHREAD_CANCEL_DISABLE 1
#define PTHREAD_CANCEL_DEFERRED 0
#define PTHREAD_CANCEL_ASYNCHRONOUS 1
/* Pthread scope */
#undef PTHREAD_SCOPE_PROCESS
#define PTHREAD_SCOPE_PROCESS 1
#undef PTHREAD_SCOPE_SYSTEM
#define PTHREAD_SCOPE_SYSTEM 0
/* Passed to pthread_once */
#define PTHREAD_ONCE_INIT {0}
/* The minimum allowable stack size */
#define PTHREAD_STACK_MIN Z_KERNEL_STACK_SIZE_ADJUST(0)
/**
* @brief Declare a condition variable as initialized
*
* Initialize a condition variable with the default condition variable attributes.
*/
#define PTHREAD_COND_INITIALIZER (-1)
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_cond_init(pthread_cond_t *cv, const pthread_condattr_t *att);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_cond_destroy(pthread_cond_t *cv);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_cond_signal(pthread_cond_t *cv);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_cond_broadcast(pthread_cond_t *cv);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_cond_wait(pthread_cond_t *cv, pthread_mutex_t *mut);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_cond_timedwait(pthread_cond_t *cv, pthread_mutex_t *mut,
const struct timespec *abstime);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1.
*
*/
int pthread_condattr_init(pthread_condattr_t *att);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*
*/
int pthread_condattr_destroy(pthread_condattr_t *att);
/**
* @brief POSIX threading comatibility API
*
* See IEEE 1003.1
*
*/
int pthread_condattr_getclock(const pthread_condattr_t *ZRESTRICT att,
clockid_t *ZRESTRICT clock_id);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*
*/
int pthread_condattr_setclock(pthread_condattr_t *att, clockid_t clock_id);
/**
* @brief Declare a mutex as initialized
*
* Initialize a mutex with the default mutex attributes.
*/
#define PTHREAD_MUTEX_INITIALIZER (-1)
/**
* @brief Declare a rwlock as initialized
*
* Initialize a rwlock with the default rwlock attributes.
*/
#define PTHREAD_RWLOCK_INITIALIZER (-1)
/*
* Mutex attributes - type
*
* PTHREAD_MUTEX_NORMAL: Owner of mutex cannot relock it. Attempting
* to relock will cause deadlock.
* PTHREAD_MUTEX_RECURSIVE: Owner can relock the mutex.
* PTHREAD_MUTEX_ERRORCHECK: If owner attempts to relock the mutex, an
* error is returned.
*
*/
#define PTHREAD_MUTEX_NORMAL 0
#define PTHREAD_MUTEX_RECURSIVE 1
#define PTHREAD_MUTEX_ERRORCHECK 2
#define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
/*
* Mutex attributes - protocol
*
* PTHREAD_PRIO_NONE: Ownership of mutex does not affect priority.
* PTHREAD_PRIO_INHERIT: Owner's priority is boosted to the priority of
* highest priority thread blocked on the mutex.
* PTHREAD_PRIO_PROTECT: Mutex has a priority ceiling. The owner's
* priority is boosted to the highest priority ceiling of all mutexes
* owned (regardless of whether or not other threads are blocked on
* any of these mutexes).
* FIXME: Only PRIO_NONE is supported. Implement other protocols.
*/
#define PTHREAD_PRIO_NONE 0
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_mutex_destroy(pthread_mutex_t *m);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_mutex_lock(pthread_mutex_t *m);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_mutex_unlock(pthread_mutex_t *m);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_mutex_timedlock(pthread_mutex_t *m,
const struct timespec *abstime);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_mutex_trylock(pthread_mutex_t *m);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_mutex_init(pthread_mutex_t *m,
const pthread_mutexattr_t *att);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr, int protocol);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr,
int *protocol);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*
* Note that pthread attribute structs are currently noops in Zephyr.
*/
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*
* Note that pthread attribute structs are currently noops in Zephyr.
*/
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
/**
* @brief Declare a pthread barrier
*
* Declaration API for a pthread barrier. This is not a
* POSIX API, it's provided to better conform with Zephyr's allocation
* strategies for kernel objects.
*
* @param name Symbol name of the barrier
* @param count Thread count, same as the "count" argument to
* pthread_barrier_init()
* @deprecated Use @ref pthread_barrier_init instead.
*/
#define PTHREAD_BARRIER_DEFINE(name, count) pthread_barrier_t name = -1 __DEPRECATED_MACRO
#define PTHREAD_BARRIER_SERIAL_THREAD 1
/*
* Barrier attributes - type
*/
#define PTHREAD_PROCESS_PRIVATE 0
#define PTHREAD_PROCESS_PUBLIC 1
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_barrier_wait(pthread_barrier_t *b);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_barrier_init(pthread_barrier_t *b, const pthread_barrierattr_t *attr,
unsigned int count);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_barrier_destroy(pthread_barrier_t *b);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_barrierattr_init(pthread_barrierattr_t *b);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_barrierattr_destroy(pthread_barrierattr_t *b);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_barrierattr_setpshared(pthread_barrierattr_t *attr, int pshared);
/**
* @brief POSIX threading compatibility API
*
* See IEEE 1003.1
*/
int pthread_barrierattr_getpshared(const pthread_barrierattr_t *ZRESTRICT attr,
int *ZRESTRICT pshared);
/* Predicates and setters for various pthread attribute values that we
* don't support (or always support: the "process shared" attribute
* can only be true given the way Zephyr implements these
* objects). Leave these undefined for simplicity instead of defining
* stubs to return an error that would have to be logged and
* interpreted just to figure out that we didn't support it in the
* first place. These APIs are very rarely used even in production
* Unix code. Leave the declarations here so they can be easily
* uncommented and implemented as needed.
int pthread_condattr_getpshared(const pthread_condattr_t * int *);
int pthread_condattr_setpshared(pthread_condattr_t *, int);
int pthread_mutex_consistent(pthread_mutex_t *);
int pthread_mutex_getprioceiling(const pthread_mutex_t * int *);
int pthread_mutex_setprioceiling(pthread_mutex_t *, int int *);
int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *, int *);
int pthread_mutexattr_getpshared(const pthread_mutexattr_t * int *);
int pthread_mutexattr_getrobust(const pthread_mutexattr_t * int *);
int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *, int);
int pthread_mutexattr_setpshared(pthread_mutexattr_t *, int);
int pthread_mutexattr_setrobust(pthread_mutexattr_t *, int);
*/
/* Base Pthread related APIs */
/**
* @brief Obtain ID of the calling thread.
*
* The results of calling this API from threads not created with
* pthread_create() are undefined.
*
* See IEEE 1003.1
*/
pthread_t pthread_self(void);
/**
* @brief Compare thread IDs.
*
* See IEEE 1003.1
*/
int pthread_equal(pthread_t pt1, pthread_t pt2);
/**
* @brief Destroy the read-write lock attributes object.
*
* See IEEE 1003.1
*/
int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);
/**
* @brief initialize the read-write lock attributes object.
*
* See IEEE 1003.1
*/
int pthread_rwlockattr_init(pthread_rwlockattr_t *attr);
int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *ZRESTRICT attr,
int *ZRESTRICT pshared);
int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr, int pshared);
int pthread_attr_getguardsize(const pthread_attr_t *ZRESTRICT attr, size_t *ZRESTRICT guardsize);
int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize);
int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize);
int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);
int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy);
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);
int pthread_attr_getschedparam(const pthread_attr_t *attr,
struct sched_param *schedparam);
int pthread_getschedparam(pthread_t pthread, int *policy,
struct sched_param *param);
int pthread_attr_getstack(const pthread_attr_t *attr,
void **stackaddr, size_t *stacksize);
int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr,
size_t stacksize);
int pthread_attr_getscope(const pthread_attr_t *attr, int *contentionscope);
int pthread_attr_setscope(pthread_attr_t *attr, int contentionscope);
#ifdef CONFIG_PTHREAD_IPC
int pthread_once(pthread_once_t *once, void (*initFunc)(void));
#endif
FUNC_NORETURN void pthread_exit(void *retval);
int pthread_join(pthread_t thread, void **status);
int pthread_cancel(pthread_t pthread);
int pthread_detach(pthread_t thread);
int pthread_create(pthread_t *newthread, const pthread_attr_t *attr,
void *(*threadroutine)(void *), void *arg);
int pthread_setcancelstate(int state, int *oldstate);
int pthread_setcanceltype(int type, int *oldtype);
void pthread_testcancel(void);
int pthread_attr_setschedparam(pthread_attr_t *attr,
const struct sched_param *schedparam);
int pthread_setschedparam(pthread_t pthread, int policy,
const struct sched_param *param);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
int pthread_rwlock_init(pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr);
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock,
const struct timespec *abstime);
int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock,
const struct timespec *abstime);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_key_create(pthread_key_t *key,
void (*destructor)(void *));
int pthread_key_delete(pthread_key_t key);
int pthread_setspecific(pthread_key_t key, const void *value);
void *pthread_getspecific(pthread_key_t key);
int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));
int pthread_getconcurrency(void);
int pthread_setconcurrency(int new_level);
void __z_pthread_cleanup_push(void *cleanup[3], void (*routine)(void *arg), void *arg);
void __z_pthread_cleanup_pop(int execute);
#define pthread_cleanup_push(_rtn, _arg) \
do /* enforce '{'-like behaviour */ { \
void *_z_pthread_cleanup[3]; \
__z_pthread_cleanup_push(_z_pthread_cleanup, _rtn, _arg)
#define pthread_cleanup_pop(_ex) \
__z_pthread_cleanup_pop(_ex); \
} /* enforce '}'-like behaviour */ while (0)
/* Glibc / Oracle Extension Functions */
/**
* @brief Set name of POSIX thread.
*
* Non-portable, extension function that conforms with most
* other definitions of this function.
*
* @param thread POSIX thread to set name
* @param name Name string
* @retval 0 Success
* @retval ESRCH Thread does not exist
* @retval EINVAL Name buffer is NULL
* @retval Negative value if kernel function error
*
*/
int pthread_setname_np(pthread_t thread, const char *name);
/**
* @brief Get name of POSIX thread and store in name buffer
* that is of size len.
*
* Non-portable, extension function that conforms with most
* other definitions of this function.
*
* @param thread POSIX thread to obtain name information
* @param name Destination buffer
* @param len Destination buffer size
* @retval 0 Success
* @retval ESRCH Thread does not exist
* @retval EINVAL Name buffer is NULL
* @retval Negative value if kernel function error
*/
int pthread_getname_np(pthread_t thread, char *name, size_t len);
#ifdef CONFIG_PTHREAD_IPC
/**
* @brief Destroy a pthread_spinlock_t.
*
* See IEEE 1003.1
*/
int pthread_spin_destroy(pthread_spinlock_t *lock);
/**
* @brief Initialize a thread_spinlock_t.
*
* See IEEE 1003.1
*/
int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
/**
* @brief Lock a previously initialized thread_spinlock_t.
*
* See IEEE 1003.1
*/
int pthread_spin_lock(pthread_spinlock_t *lock);
/**
* @brief Attempt to lock a previously initialized thread_spinlock_t.
*
* See IEEE 1003.1
*/
int pthread_spin_trylock(pthread_spinlock_t *lock);
/**
* @brief Unlock a previously locked thread_spinlock_t.
*
* See IEEE 1003.1
*/
int pthread_spin_unlock(pthread_spinlock_t *lock);
#endif
#ifdef __cplusplus
}
#endif
#endif /* ZEPHYR_INCLUDE_POSIX_PTHREAD_H_ */