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
|
/* Low-level lock implementation. High-level Hurd helpers.
Copyright (C) 1999-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 _HURD_LOCK_H
#define _HURD_LOCK_H 1
#include <mach/lowlevellock.h>
struct timespec;
/* Flags for robust locks. */
#define LLL_WAITERS (1U << 31)
#define LLL_DEAD_OWNER (1U << 30)
#define LLL_OWNER_MASK ~(LLL_WAITERS | LLL_DEAD_OWNER)
/* Wait on 64-bit address PTR, without blocking if its contents
are different from the pair <LO, HI>. */
#define __lll_xwait(ptr, lo, hi, flags) \
__gsync_wait (__mach_task_self (), \
(vm_offset_t)ptr, lo, hi, 0, flags | GSYNC_QUAD)
/* Same as '__lll_wait', but only block for MLSEC milliseconds. */
#define __lll_timed_wait(ptr, val, mlsec, flags) \
__gsync_wait (__mach_task_self (), \
(vm_offset_t)ptr, val, 0, mlsec, flags | GSYNC_TIMED)
/* Interruptible version. */
#define __lll_timed_wait_intr(ptr, val, mlsec, flags) \
__gsync_wait_intr (__mach_task_self (), \
(vm_offset_t)ptr, val, 0, mlsec, flags | GSYNC_TIMED)
/* Same as '__lll_xwait', but only block for MLSEC milliseconds. */
#define __lll_timed_xwait(ptr, lo, hi, mlsec, flags) \
__gsync_wait (__mach_task_self (), (vm_offset_t)ptr, \
lo, hi, mlsec, flags | GSYNC_TIMED | GSYNC_QUAD)
/* Same as '__lll_wait', but only block until TSP elapses,
using clock CLK. */
extern int __lll_abstimed_wait (void *__ptr, int __val,
const struct timespec *__tsp, int __flags, int __clk);
/* Interruptible version. */
extern int __lll_abstimed_wait_intr (void *__ptr, int __val,
const struct timespec *__tsp, int __flags, int __clk);
/* Same as 'lll_xwait', but only block until TSP elapses,
using clock CLK. */
extern int __lll_abstimed_xwait (void *__ptr, int __lo, int __hi,
const struct timespec *__tsp, int __flags, int __clk);
/* Same as 'lll_lock', but return with an error if TSP elapses,
using clock CLK. */
extern int __lll_abstimed_lock (void *__ptr,
const struct timespec *__tsp, int __flags, int __clk);
/* Acquire the lock at PTR, but return with an error if
the process containing the owner thread dies. */
extern int __lll_robust_lock (void *__ptr, int __flags);
#define lll_robust_lock(var, flags) \
__lll_robust_lock (&(var), flags)
/* Same as '__lll_robust_lock', but only block until TSP
elapses, using clock CLK. */
extern int __lll_robust_abstimed_lock (void *__ptr,
const struct timespec *__tsp, int __flags, int __clk);
/* Same as '__lll_robust_lock', but return with an error
if the lock cannot be acquired without blocking. */
extern int __lll_robust_trylock (void *__ptr);
#define lll_robust_trylock(var) \
__lll_robust_trylock (&(var))
/* Wake one or more threads waiting on address PTR,
setting its value to VAL before doing so. */
#define __lll_set_wake(ptr, val, flags) \
__gsync_wake (__mach_task_self (), \
(vm_offset_t)ptr, val, flags | GSYNC_MUTATE)
/* Release the robust lock at PTR. */
extern void __lll_robust_unlock (void *__ptr, int __flags);
#define lll_robust_unlock(var, flags) \
__lll_robust_unlock (&(var), flags)
/* Rearrange threads waiting on address SRC to instead wait on
DST, waking one of them if WAIT_ONE is non-zero. */
#define __lll_requeue(src, dst, wake_one, flags) \
__gsync_requeue (__mach_task_self (), (vm_offset_t)src, \
(vm_offset_t)dst, (boolean_t)wake_one, flags)
/* The following are hacks that allow us to simulate optional
parameters in C, to avoid having to pass the clock id for
every one of these calls, defaulting to CLOCK_REALTIME if
no argument is passed. */
#define lll_abstimed_wait(var, val, tsp, flags, ...) \
({ \
const clockid_t __clk[] = { CLOCK_REALTIME, ##__VA_ARGS__ }; \
__lll_abstimed_wait (&(var), (val), (tsp), (flags), \
__clk[sizeof (__clk) / sizeof (__clk[0]) - 1]); \
})
#define lll_abstimed_wait_intr(var, val, tsp, flags, ...) \
({ \
const clockid_t __clk[] = { CLOCK_REALTIME, ##__VA_ARGS__ }; \
__lll_abstimed_wait_intr (&(var), (val), (tsp), (flags), \
__clk[sizeof (__clk) / sizeof (__clk[0]) - 1]); \
})
#define lll_abstimed_xwait(var, lo, hi, tsp, flags, ...) \
({ \
const clockid_t __clk[] = { CLOCK_REALTIME, ##__VA_ARGS__ }; \
__lll_abstimed_xwait (&(var), (lo), (hi), (tsp), (flags), \
__clk[sizeof (__clk) / sizeof (__clk[0]) - 1]); \
})
#define lll_abstimed_lock(var, tsp, flags, ...) \
({ \
const clockid_t __clk[] = { CLOCK_REALTIME, ##__VA_ARGS__ }; \
__lll_abstimed_lock (&(var), (tsp), (flags), \
__clk[sizeof (__clk) / sizeof (__clk[0]) - 1]); \
})
#define lll_robust_abstimed_lock(var, tsp, flags, ...) \
({ \
const clockid_t __clk[] = { CLOCK_REALTIME, ##__VA_ARGS__ }; \
__lll_robust_abstimed_lock (&(var), (tsp), (flags), \
__clk[sizeof (__clk) / sizeof (__clk[0]) - 1]); \
})
#endif
|
