]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/basic/barrier.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2014 David Herrmann <dh.herrmann@gmail.com>
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
28 #include <sys/eventfd.h>
29 #include <sys/types.h>
39 * This barrier implementation provides a simple synchronization method based
40 * on file-descriptors that can safely be used between threads and processes. A
41 * barrier object contains 2 shared counters based on eventfd. Both processes
42 * can now place barriers and wait for the other end to reach a random or
44 * Barriers are numbered, so you can either wait for the other end to reach any
45 * barrier or the last barrier that you placed. This way, you can use barriers
46 * for one-way *and* full synchronization. Note that even-though barriers are
47 * numbered, these numbers are internal and recycled once both sides reached the
48 * same barrier (implemented as a simple signed counter). It is thus not
49 * possible to address barriers by their ID.
51 * Barrier-API: Both ends can place as many barriers via barrier_place() as
52 * they want and each pair of barriers on both sides will be implicitly linked.
53 * Each side can use the barrier_wait/sync_*() family of calls to wait for the
54 * other side to place a specific barrier. barrier_wait_next() waits until the
55 * other side calls barrier_place(). No links between the barriers are
56 * considered and this simply serves as most basic asynchronous barrier.
57 * barrier_sync_next() is like barrier_wait_next() and waits for the other side
58 * to place their next barrier via barrier_place(). However, it only waits for
59 * barriers that are linked to a barrier we already placed. If the other side
60 * already placed more barriers than we did, barrier_sync_next() returns
62 * barrier_sync() extends barrier_sync_next() and waits until the other end
63 * placed as many barriers via barrier_place() as we did. If they already placed
64 * as many as we did (or more), it returns immediately.
66 * Additionally to basic barriers, an abortion event is available.
67 * barrier_abort() places an abortion event that cannot be undone. An abortion
68 * immediately cancels all placed barriers and replaces them. Any running and
69 * following wait/sync call besides barrier_wait_abortion() will immediately
70 * return false on both sides (otherwise, they always return true).
71 * barrier_abort() can be called multiple times on both ends and will be a
72 * no-op if already called on this side.
73 * barrier_wait_abortion() can be used to wait for the other side to call
74 * barrier_abort() and is the only wait/sync call that does not return
75 * immediately if we aborted outself. It only returns once the other side
76 * called barrier_abort().
78 * Barriers can be used for in-process and inter-process synchronization.
79 * However, for in-process synchronization you could just use mutexes.
80 * Therefore, main target is IPC and we require both sides to *not* share the FD
81 * table. If that's given, barriers provide target tracking: If the remote side
82 * exit()s, an abortion event is implicitly queued on the other side. This way,
83 * a sync/wait call will be woken up if the remote side crashed or exited
84 * unexpectedly. However, note that these abortion events are only queued if the
85 * barrier-queue has been drained. Therefore, it is safe to place a barrier and
86 * exit. The other side can safely wait on the barrier even though the exit
87 * queued an abortion event. Usually, the abortion event would overwrite the
88 * barrier, however, that's not true for exit-abortion events. Those are only
89 * queued if the barrier-queue is drained (thus, the receiving side has placed
90 * more barriers than the remote side).
94 * barrier_create() - Initialize a barrier object
95 * @obj: barrier to initialize
97 * This initializes a barrier object. The caller is responsible of allocating
98 * the memory and keeping it valid. The memory does not have to be zeroed
100 * Two eventfd objects are allocated for each barrier. If allocation fails, an
103 * If this function fails, the barrier is reset to an invalid state so it is
104 * safe to call barrier_destroy() on the object regardless whether the
105 * initialization succeeded or not.
107 * The caller is responsible to destroy the object via barrier_destroy() before
108 * releasing the underlying memory.
110 * Returns: 0 on success, negative error code on failure.
112 int barrier_create(Barrier
*b
) {
113 _cleanup_(barrier_destroyp
) Barrier
*staging
= b
;
118 b
->me
= eventfd(0, EFD_CLOEXEC
| EFD_NONBLOCK
);
122 b
->them
= eventfd(0, EFD_CLOEXEC
| EFD_NONBLOCK
);
126 r
= pipe2(b
->pipe
, O_CLOEXEC
| O_NONBLOCK
);
135 * barrier_destroy() - Destroy a barrier object
136 * @b: barrier to destroy or NULL
138 * This destroys a barrier object that has previously been passed to
139 * barrier_create(). The object is released and reset to invalid
140 * state. Therefore, it is safe to call barrier_destroy() multiple
141 * times or even if barrier_create() failed. However, barrier must be
142 * always initialized with BARRIER_NULL.
144 * If @b is NULL, this is a no-op.
146 void barrier_destroy(Barrier
*b
) {
150 b
->me
= safe_close(b
->me
);
151 b
->them
= safe_close(b
->them
);
152 safe_close_pair(b
->pipe
);
157 * barrier_set_role() - Set the local role of the barrier
158 * @b: barrier to operate on
159 * @role: role to set on the barrier
161 * This sets the roles on a barrier object. This is needed to know
162 * which side of the barrier you're on. Usually, the parent creates
163 * the barrier via barrier_create() and then calls fork() or clone().
164 * Therefore, the FDs are duplicated and the child retains the same
167 * Both sides need to call barrier_set_role() after fork() or clone()
168 * are done. If this is not done, barriers will not work correctly.
170 * Note that barriers could be supported without fork() or clone(). However,
171 * this is currently not needed so it hasn't been implemented.
173 void barrier_set_role(Barrier
*b
, unsigned int role
) {
177 assert(role
== BARRIER_PARENT
|| role
== BARRIER_CHILD
);
178 /* make sure this is only called once */
179 assert(b
->pipe
[0] >= 0 && b
->pipe
[1] >= 0);
181 if (role
== BARRIER_PARENT
)
182 b
->pipe
[1] = safe_close(b
->pipe
[1]);
184 b
->pipe
[0] = safe_close(b
->pipe
[0]);
186 /* swap me/them for children */
193 /* places barrier; returns false if we aborted, otherwise true */
194 static bool barrier_write(Barrier
*b
, uint64_t buf
) {
197 /* prevent new sync-points if we already aborted */
198 if (barrier_i_aborted(b
))
202 len
= write(b
->me
, &buf
, sizeof(buf
));
203 } while (len
< 0 && IN_SET(errno
, EAGAIN
, EINTR
));
205 if (len
!= sizeof(buf
))
208 /* lock if we aborted */
209 if (buf
>= (uint64_t)BARRIER_ABORTION
) {
210 if (barrier_they_aborted(b
))
211 b
->barriers
= BARRIER_WE_ABORTED
;
213 b
->barriers
= BARRIER_I_ABORTED
;
214 } else if (!barrier_is_aborted(b
))
217 return !barrier_i_aborted(b
);
220 /* If there is an unexpected error, we have to make this fatal. There
221 * is no way we can recover from sync-errors. Therefore, we close the
222 * pipe-ends and treat this as abortion. The other end will notice the
223 * pipe-close and treat it as abortion, too. */
225 safe_close_pair(b
->pipe
);
226 b
->barriers
= BARRIER_WE_ABORTED
;
230 /* waits for barriers; returns false if they aborted, otherwise true */
231 static bool barrier_read(Barrier
*b
, int64_t comp
) {
232 if (barrier_they_aborted(b
))
235 while (b
->barriers
> comp
) {
236 struct pollfd pfd
[2] = {
237 { .fd
= b
->pipe
[0] >= 0 ? b
->pipe
[0] : b
->pipe
[1],
244 r
= poll(pfd
, 2, -1);
245 if (r
< 0 && IN_SET(errno
, EAGAIN
, EINTR
))
250 if (pfd
[1].revents
) {
253 /* events on @them signal new data for us */
254 len
= read(b
->them
, &buf
, sizeof(buf
));
255 if (len
< 0 && IN_SET(errno
, EAGAIN
, EINTR
))
258 if (len
!= sizeof(buf
))
260 } else if (pfd
[0].revents
& (POLLHUP
| POLLERR
| POLLNVAL
))
261 /* POLLHUP on the pipe tells us the other side exited.
262 * We treat this as implicit abortion. But we only
263 * handle it if there's no event on the eventfd. This
264 * guarantees that exit-abortions do not overwrite real
266 buf
= BARRIER_ABORTION
;
270 /* lock if they aborted */
271 if (buf
>= (uint64_t)BARRIER_ABORTION
) {
272 if (barrier_i_aborted(b
))
273 b
->barriers
= BARRIER_WE_ABORTED
;
275 b
->barriers
= BARRIER_THEY_ABORTED
;
276 } else if (!barrier_is_aborted(b
))
280 return !barrier_they_aborted(b
);
283 /* If there is an unexpected error, we have to make this fatal. There
284 * is no way we can recover from sync-errors. Therefore, we close the
285 * pipe-ends and treat this as abortion. The other end will notice the
286 * pipe-close and treat it as abortion, too. */
288 safe_close_pair(b
->pipe
);
289 b
->barriers
= BARRIER_WE_ABORTED
;
294 * barrier_place() - Place a new barrier
297 * This places a new barrier on the barrier object. If either side already
298 * aborted, this is a no-op and returns "false". Otherwise, the barrier is
299 * placed and this returns "true".
301 * Returns: true if barrier was placed, false if either side aborted.
303 bool barrier_place(Barrier
*b
) {
306 if (barrier_is_aborted(b
))
309 barrier_write(b
, BARRIER_SINGLE
);
314 * barrier_abort() - Abort the synchronization
315 * @b: barrier object to abort
317 * This aborts the barrier-synchronization. If barrier_abort() was already
318 * called on this side, this is a no-op. Otherwise, the barrier is put into the
319 * ABORT-state and will stay there. The other side is notified about the
320 * abortion. Any following attempt to place normal barriers or to wait on normal
321 * barriers will return immediately as "false".
323 * You can wait for the other side to call barrier_abort(), too. Use
324 * barrier_wait_abortion() for that.
326 * Returns: false if the other side already aborted, true otherwise.
328 bool barrier_abort(Barrier
*b
) {
331 barrier_write(b
, BARRIER_ABORTION
);
332 return !barrier_they_aborted(b
);
336 * barrier_wait_next() - Wait for the next barrier of the other side
337 * @b: barrier to operate on
339 * This waits until the other side places its next barrier. This is independent
340 * of any barrier-links and just waits for any next barrier of the other side.
342 * If either side aborted, this returns false.
344 * Returns: false if either side aborted, true otherwise.
346 bool barrier_wait_next(Barrier
*b
) {
349 if (barrier_is_aborted(b
))
352 barrier_read(b
, b
->barriers
- 1);
353 return !barrier_is_aborted(b
);
357 * barrier_wait_abortion() - Wait for the other side to abort
358 * @b: barrier to operate on
360 * This waits until the other side called barrier_abort(). This can be called
361 * regardless whether the local side already called barrier_abort() or not.
363 * If the other side has already aborted, this returns immediately.
365 * Returns: false if the local side aborted, true otherwise.
367 bool barrier_wait_abortion(Barrier
*b
) {
370 barrier_read(b
, BARRIER_THEY_ABORTED
);
371 return !barrier_i_aborted(b
);
375 * barrier_sync_next() - Wait for the other side to place a next linked barrier
376 * @b: barrier to operate on
378 * This is like barrier_wait_next() and waits for the other side to call
379 * barrier_place(). However, this only waits for linked barriers. That means, if
380 * the other side already placed more barriers than (or as much as) we did, this
381 * returns immediately instead of waiting.
383 * If either side aborted, this returns false.
385 * Returns: false if either side aborted, true otherwise.
387 bool barrier_sync_next(Barrier
*b
) {
390 if (barrier_is_aborted(b
))
393 barrier_read(b
, MAX((int64_t)0, b
->barriers
- 1));
394 return !barrier_is_aborted(b
);
398 * barrier_sync() - Wait for the other side to place as many barriers as we did
399 * @b: barrier to operate on
401 * This is like barrier_sync_next() but waits for the other side to call
402 * barrier_place() as often as we did (in total). If they already placed as much
403 * as we did (or more), this returns immediately instead of waiting.
405 * If either side aborted, this returns false.
407 * Returns: false if either side aborted, true otherwise.
409 bool barrier_sync(Barrier
*b
) {
412 if (barrier_is_aborted(b
))
416 return !barrier_is_aborted(b
);