Code Coverage: vinyl-cache/bin/vinyltest/vtest2/src/vtc_barrier.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2005 Varnish Software AS
2
 * All rights reserved.
3
 *
4
 * Author: Dridi Boukelmoune <dridi@varnish-software.com>
5
 *
6
 * SPDX-License-Identifier: BSD-2-Clause
7
 *
8
 * Redistribution and use in source and binary forms, with or without
9
 * modification, are permitted provided that the following conditions
10
 * are met:
11
 * 1. Redistributions of source code must retain the above copyright
12
 *    notice, this list of conditions and the following disclaimer.
13
 * 2. Redistributions in binary form must reproduce the above copyright
14
 *    notice, this list of conditions and the following disclaimer in the
15
 *    documentation and/or other materials provided with the distribution.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
 * SUCH DAMAGE.
28
 */
29
30
#include "config.h"
31
32
#include <poll.h>
33
#include <stdio.h>
34
#include <stdlib.h>
35
#include <string.h>
36
#include <unistd.h>
37
38
#include <sys/socket.h>
39
#include <sys/time.h> /* for MUSL */
40
41
#include "vtc.h"
42
43
#include "vtcp.h"
44
#include "vtim.h"
45
#include "vsa.h"
46
47
enum barrier_e {
48
        BARRIER_NONE = 0,
49
        BARRIER_COND,
50
        BARRIER_SOCK,
51
};
52
53
struct barrier {
54
        unsigned                magic;
55
#define BARRIER_MAGIC           0x7b54c275
56
        char                    *name;
57
        VTAILQ_ENTRY(barrier)   list;
58
        pthread_mutex_t         mtx;
59
        pthread_cond_t          cond;
60
61
        int                     waiters;
62
        int                     expected;
63
        int                     cyclic;
64
65
        enum barrier_e          type;
66
        union {
67
                int             cond_cycle;
68
                pthread_t       sock_thread;
69
        };
70
};
71
72
static VTAILQ_HEAD(, barrier)   barriers = VTAILQ_HEAD_INITIALIZER(barriers);
73
74
static struct barrier *
75
barrier_new(const char *name, struct vtclog *vl)
76 249
{
77 249
        struct barrier *b;
78
79 249
        ALLOC_OBJ(b, BARRIER_MAGIC);
80 249
        AN(b);
81 249
        if (!pthread_equal(pthread_self(), vtc_thread))
82 0
                vtc_fatal(vl,
83 0
                    "Barrier %s can only be created on the top thread", name);
84 249
        REPLACE(b->name, name);
85
86 249
        PTOK(pthread_mutex_init(&b->mtx, NULL));
87 249
        PTOK(pthread_cond_init(&b->cond, NULL));
88 249
        b->waiters = 0;
89 249
        b->expected = 0;
90 249
        VTAILQ_INSERT_TAIL(&barriers, b, list);
91 249
        return (b);
92 249
}
93
94
/**********************************************************************
95
 * Init a barrier
96
 */
97
98
static void
99
barrier_expect(struct barrier *b, const char *av, struct vtclog *vl)
100 249
{
101 249
        unsigned expected;
102
103 249
        if (b->type != BARRIER_NONE)
104 0
                vtc_fatal(vl,
105 0
                    "Barrier(%s) use error: already initialized", b->name);
106
107 249
        AZ(b->expected);
108 249
        AZ(b->waiters);
109 249
        expected = strtoul(av, NULL, 0);
110 249
        if (expected < 2)
111 0
                vtc_fatal(vl,
112 0
                    "Barrier(%s) use error: wrong expectation (%u)",
113 0
                    b->name, expected);
114
115 249
        b->expected = expected;
116 249
}
117
118
static void
119
barrier_cond(struct barrier *b, const char *av, struct vtclog *vl)
120 187
{
121
122 187
        CHECK_OBJ_NOTNULL(b, BARRIER_MAGIC);
123 187
        PTOK(pthread_mutex_lock(&b->mtx));
124 187
        barrier_expect(b, av, vl);
125 187
        b->type = BARRIER_COND;
126 187
        PTOK(pthread_mutex_unlock(&b->mtx));
127 187
}
128
129
static void *
130
barrier_sock_thread(void *priv)
131 62
{
132 62
        struct barrier *b;
133 62
        struct vtclog *vl;
134 62
        const char *err;
135 62
        char buf[vsa_suckaddr_len];
136 62
        const struct suckaddr *sua;
137
138 62
        char abuf[VTCP_ADDRBUFSIZE], pbuf[VTCP_PORTBUFSIZE];
139 62
        int i, sock, *conns;
140 62
        struct pollfd pfd[1];
141
142 62
        CAST_OBJ_NOTNULL(b, priv, BARRIER_MAGIC);
143 62
        assert(b->type == BARRIER_SOCK);
144
145 62
        PTOK(pthread_mutex_lock(&b->mtx));
146
147 62
        vl = vtc_logopen("%s", b->name);
148 62
        pthread_cleanup_push(vtc_logclose, vl);
149
150 62
        sock = VTCP_listen_on(default_listen_addr, NULL, b->expected, &err);
151 62
        if (sock < 0) {
152 0
                PTOK(pthread_cond_signal(&b->cond));
153 0
                PTOK(pthread_mutex_unlock(&b->mtx));
154 0
                vtc_fatal(vl, "Barrier(%s) %s fails: %s (errno=%d)",
155 0
                    b->name, err, strerror(errno), errno);
156 0
        }
157 62
        assert(sock > 0);
158 62
        VTCP_nonblocking(sock);
159 62
        sua = VSA_getsockname(sock, buf, sizeof buf);
160 62
        AN(sua);
161 62
        VTCP_name(sua, abuf, sizeof abuf, pbuf, sizeof pbuf);
162
163 62
        macro_def(vl, b->name, "addr", "%s", abuf);
164 62
        macro_def(vl, b->name, "port", "%s", pbuf);
165 62
        if (VSA_Get_Proto(sua) == AF_INET)
166 62
                macro_def(vl, b->name, "sock", "%s:%s", abuf, pbuf);
167 0
        else
168 0
                macro_def(vl, b->name, "sock", "[%s]:%s", abuf, pbuf);
169
170 62
        PTOK(pthread_cond_signal(&b->cond));
171 62
        PTOK(pthread_mutex_unlock(&b->mtx));
172
173 62
        conns = calloc(b->expected, sizeof *conns);
174 62
        AN(conns);
175
176 1127
        while (!vtc_stop && !vtc_error) {
177 1113
                pfd[0].fd = sock;
178 1113
                pfd[0].events = POLLIN;
179
180 1113
                i = poll(pfd, 1, 100);
181 1113
                if (i == 0)
182 910
                        continue;
183 203
                if (i < 0) {
184 0
                        if (errno == EINTR)
185 0
                                continue;
186 0
                        closefd(&sock);
187 0
                        vtc_fatal(vl,
188 0
                            "Barrier(%s) select fails: %s (errno=%d)",
189 0
                            b->name, strerror(errno), errno);
190 0
                }
191 203
                assert(i == 1);
192 203
                assert(b->waiters <= b->expected);
193 203
                if (b->waiters == b->expected)
194 0
                        vtc_fatal(vl,
195 0
                            "Barrier(%s) use error: "
196 0
                            "more waiters than the %u expected",
197 0
                            b->name, b->expected);
198
199 203
                i = accept(sock, NULL, NULL);
200 203
                if (i < 0) {
201 0
                        closefd(&sock);
202 0
                        vtc_fatal(vl,
203 0
                            "Barrier(%s) accept fails: %s (errno=%d)",
204 0
                            b->name, strerror(errno), errno);
205 0
                }
206
207
                /* NB. We don't keep track of the established connections, only
208
                 *     that connections were made to the barrier's socket.
209
                 */
210 203
                conns[b->waiters] = i;
211
212 203
                if (++b->waiters < b->expected) {
213 128
                        vtc_log(vl, 4, "Barrier(%s) wait %u of %u",
214 128
                            b->name, b->waiters, b->expected);
215 128
                        continue;
216 128
                }
217
218 75
                vtc_log(vl, 4, "Barrier(%s) wake %u", b->name, b->expected);
219 280
                for (i = 0; i < b->expected; i++)
220 205
                        closefd(&conns[i]);
221
222 75
                if (b->cyclic)
223 27
                        b->waiters = 0;
224 48
                else
225 48
                        break;
226 75
        }
227
228 62
        if (b->waiters % b->expected > 0) {
229
                /* wake up outstanding waiters */
230 0
                for (i = 0; i < b->waiters; i++)
231 0
                        closefd(&conns[i]);
232 0
                if (!vtc_error)
233 0
                        vtc_fatal(vl, "Barrier(%s) has %u outstanding waiters",
234 0
                            b->name, b->waiters);
235 0
        }
236
237 62
        macro_undef(vl, b->name, "addr");
238 62
        macro_undef(vl, b->name, "port");
239 62
        macro_undef(vl, b->name, "sock");
240 62
        closefd(&sock);
241 62
        free(conns);
242 62
        pthread_cleanup_pop(0);
243 62
        vtc_logclose(vl);
244 62
        return (NULL);
245 62
}
246
247
static void
248
barrier_sock(struct barrier *b, const char *av, struct vtclog *vl)
249 62
{
250
251 62
        CHECK_OBJ_NOTNULL(b, BARRIER_MAGIC);
252 62
        PTOK(pthread_mutex_lock(&b->mtx));
253 62
        barrier_expect(b, av, vl);
254 62
        b->type = BARRIER_SOCK;
255
256
        /* NB. We can use the BARRIER_COND's pthread_cond_t to wait until the
257
         *     socket is ready for convenience.
258
         */
259 62
        PTOK(pthread_create(&b->sock_thread, NULL, barrier_sock_thread, b));
260 62
        PTOK(pthread_cond_wait(&b->cond, &b->mtx));
261 62
        PTOK(pthread_mutex_unlock(&b->mtx));
262 62
}
263
264
static void
265
barrier_cyclic(struct barrier *b, struct vtclog *vl)
266 25
{
267 25
        enum barrier_e t;
268 25
        int w;
269
270 25
        CHECK_OBJ_NOTNULL(b, BARRIER_MAGIC);
271
272 25
        PTOK(pthread_mutex_lock(&b->mtx));
273 25
        t = b->type;
274 25
        w = b->waiters;
275 25
        PTOK(pthread_mutex_unlock(&b->mtx));
276
277 25
        if (t == BARRIER_NONE)
278 0
                vtc_fatal(vl,
279 0
                    "Barrier(%s) use error: not initialized", b->name);
280
281 25
        if (w != 0)
282 0
                vtc_fatal(vl,
283 0
                    "Barrier(%s) use error: already in use", b->name);
284
285 25
        PTOK(pthread_mutex_lock(&b->mtx));
286 25
        b->cyclic = 1;
287 25
        PTOK(pthread_mutex_unlock(&b->mtx));
288 25
}
289
290
/**********************************************************************
291
 * Sync a barrier
292
 */
293
294
static void
295
barrier_cond_sync(struct barrier *b, struct vtclog *vl)
296 475
{
297 475
        struct timespec ts;
298 475
        int r, w, c;
299
300 475
        CHECK_OBJ_NOTNULL(b, BARRIER_MAGIC);
301 475
        assert(b->type == BARRIER_COND);
302
303 475
        PTOK(pthread_mutex_lock(&b->mtx));
304 475
        w = b->waiters;
305 475
        assert(w <= b->expected);
306
307 475
        if (w == b->expected)
308 0
                w = -1;
309 475
        else
310 475
                b->waiters = ++w;
311
312 475
        c = b->cond_cycle;
313 475
        PTOK(pthread_mutex_unlock(&b->mtx));
314
315 475
        if (w < 0)
316 0
                vtc_fatal(vl,
317 0
                    "Barrier(%s) use error: more waiters than the %u expected",
318 0
                    b->name, b->expected);
319
320 475
        PTOK(pthread_mutex_lock(&b->mtx));
321 475
        if (w == b->expected) {
322 205
                vtc_log(vl, 4, "Barrier(%s) wake %u", b->name, b->expected);
323 205
                b->cond_cycle++;
324 205
                if (b->cyclic)
325 33
                        b->waiters = 0;
326 205
                PTOK(pthread_cond_broadcast(&b->cond));
327 270
        } else {
328 270
                vtc_log(vl, 4, "Barrier(%s) wait %u of %u",
329 270
                    b->name, b->waiters, b->expected);
330 1121
                do {
331 1121
                        ts = VTIM_timespec(VTIM_real() + .1);
332 1121
                        r = pthread_cond_timedwait(&b->cond, &b->mtx, &ts);
333 1121
                        assert(r == 0 || r == ETIMEDOUT);
334 1121
                } while (!vtc_stop && !vtc_error && r == ETIMEDOUT &&
335 1121
                    c == b->cond_cycle);
336 270
        }
337 475
        PTOK(pthread_mutex_unlock(&b->mtx));
338 475
}
339
340
static void
341
barrier_sock_sync(const struct barrier *b, struct vtclog *vl)
342 125
{
343 125
        struct vsb *vsb;
344 125
        const char *err;
345 125
        char buf[32];
346 125
        int i, sock;
347 125
        ssize_t sz;
348
349 125
        CHECK_OBJ_NOTNULL(b, BARRIER_MAGIC);
350 125
        assert(b->type == BARRIER_SOCK);
351
352 125
        vsb = macro_expandf(vl, "${%s_sock}", b->name);
353 125
        vtc_log(vl, 4, "Barrier(%s) sync with socket", b->name);
354
355 125
        sock = VTCP_open(VSB_data(vsb), NULL, 0., &err);
356 125
        if (sock < 0)
357 0
                vtc_fatal(vl, "Barrier(%s) connection failed: %s",
358 0
                    b->name, err);
359
360 125
        VSB_destroy(&vsb);
361
362 125
        sz = read(sock, buf, sizeof buf); /* XXX loop with timeout? */
363 125
        i = errno;
364 125
        closefd(&sock);
365
366 125
        if (sz < 0)
367 0
                vtc_fatal(vl, "Barrier(%s) read failed: %s (errno=%d)",
368 0
                    b->name, strerror(i), i);
369 125
        if (sz > 0)
370 0
                vtc_fatal(vl, "Barrier(%s) unexpected data (%zdB)",
371 0
                    b->name, sz);
372 125
}
373
374
static void
375
barrier_sync(struct barrier *b, struct vtclog *vl)
376 600
{
377
378 600
        CHECK_OBJ_NOTNULL(b, BARRIER_MAGIC);
379
380 600
        switch (b->type) {
381 0
        case BARRIER_NONE:
382 0
                vtc_fatal(vl,
383 0
                    "Barrier(%s) use error: not initialized", b->name);
384 0
                break;
385 475
        case BARRIER_COND:
386 475
                barrier_cond_sync(b, vl);
387 475
                break;
388 125
        case BARRIER_SOCK:
389 125
                barrier_sock_sync(b, vl);
390 125
                break;
391 0
        default:
392 0
                WRONG("Wrong barrier type");
393 600
        }
394 600
}
395
396
/* SECTION: barrier barrier
397
 *
398
 * NOTE: This command is available everywhere commands are given.
399
 *
400
 * Barriers allows you to synchronize different threads to make sure events
401
 * occur in the right order. It's even possible to use them in VCL.
402
 *
403
 * First, it's necessary to declare the barrier::
404
 *
405
 *         barrier bNAME TYPE NUMBER [-cyclic]
406
 *
407
 * With the arguments being:
408
 *
409
 * bNAME
410
 *         this is the name of the barrier, used to identify it when you'll
411
 *         create sync points. It must start with 'b'.
412
 *
413
 * TYPE
414
 *         it can be "cond" (mutex) or "sock" (socket) and sets internal
415
 *         behavior. If you don't need VCL synchronization, use cond.
416
 *
417
 * NUMBER
418
 *         number of sync point needed to go through the barrier.
419
 *
420
 * \-cyclic
421
 *         if present, the barrier will reset itself and be ready for another
422
 *         round once gotten through.
423
 *
424
 * Then, to add a sync point::
425
 *
426
 *         barrier bNAME sync
427
 *
428
 * This will block the parent thread until the number of sync points for bNAME
429
 * reaches the NUMBER given in the barrier declaration.
430
 *
431
 * If you wish to synchronize the VCL, you need to declare a "sock" barrier.
432
 * This will emit a macro definition named "bNAME_sock" that you can use in
433
 * VCL (after importing the vtc vmod)::
434
 *
435
 *         vtc.barrier_sync("${bNAME_sock}");
436
 *
437
 * This function returns 0 if everything went well and is the equivalent of
438
 * ``barrier bNAME sync`` at the VTC top-level.
439
 *
440
 *
441
 */
442
443
void
444
cmd_barrier(CMD_ARGS)
445 1971
{
446 1971
        struct barrier *b, *b2;
447 1971
        int r;
448
449 1971
        (void)priv;
450
451 1971
        if (av == NULL) {
452
                /* Reset and free */
453 1122
                VTAILQ_FOREACH_SAFE(b, &barriers, list, b2) {
454 249
                        r = pthread_mutex_trylock(&b->mtx);
455 249
                        assert(r == 0 || r == EBUSY);
456 249
                        switch (b->type) {
457 187
                        case BARRIER_COND:
458 187
                                break;
459 62
                        case BARRIER_SOCK:
460 62
                                PTOK(pthread_join(b->sock_thread, NULL));
461 62
                                break;
462 62
                        default:
463 0
                                WRONG("Wrong barrier type");
464 249
                        }
465 249
                        if (r == 0)
466 249
                                PTOK(pthread_mutex_unlock(&b->mtx));
467 249
                }
468 1122
                return;
469 1122
        }
470
471 849
        AZ(vstrcmp(av[0], "barrier"));
472 849
        av++;
473
474 849
        VTC_CHECK_NAME(vl, av[0], "Barrier", 'b');
475 849
        VTAILQ_FOREACH(b, &barriers, list)
476 1385
                if (!vstrcmp(b->name, av[0]))
477 600
                        break;
478 849
        if (b == NULL)
479 249
                b = barrier_new(av[0], vl);
480 849
        av++;
481
482 1723
        for (; *av != NULL; av++) {
483 874
                if (!vstrcmp(*av, "cond")) {
484 187
                        av++;
485 187
                        AN(*av);
486 187
                        barrier_cond(b, *av, vl);
487 187
                        continue;
488 187
                }
489 687
                if (!vstrcmp(*av, "sock")) {
490 62
                        av++;
491 62
                        AN(*av);
492 62
                        barrier_sock(b, *av, vl);
493 62
                        continue;
494 62
                }
495 625
                if (!vstrcmp(*av, "sync")) {
496 600
                        barrier_sync(b, vl);
497 600
                        continue;
498 600
                }
499 25
                if (!vstrcmp(*av, "-cyclic")) {
500 25
                        barrier_cyclic(b, vl);
501 25
                        continue;
502 25
                }
503 0
                vtc_fatal(vl, "Unknown barrier argument: %s", *av);
504 25
        }
505 849
}