Code Coverage: vinyl-cache/bin/vinyld/acceptor/cache_acceptor_uds.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2015 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 *
7
 * SPDX-License-Identifier: BSD-2-Clause
8
 *
9
 * Redistribution and use in source and binary forms, with or without
10
 * modification, are permitted provided that the following conditions
11
 * are met:
12
 * 1. Redistributions of source code must retain the above copyright
13
 *    notice, this list of conditions and the following disclaimer.
14
 * 2. Redistributions in binary form must reproduce the above copyright
15
 *    notice, this list of conditions and the following disclaimer in the
16
 *    documentation and/or other materials provided with the distribution.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28
 * SUCH DAMAGE.
29
 *
30
 */
31
32
#include "config.h"
33
34
#include <stdlib.h>
35
#include <netinet/in.h>
36
#include <netinet/tcp.h>
37
38
#include "cache/cache_int.h"
39
40
#include "acceptor/cache_acceptor.h"
41
#include "acceptor/acceptor_priv.h"
42
#include "acceptor/acceptor_uds.h"
43
44
#include "cache/cache_transport.h"
45
#include "cache/cache_pool.h"
46
#include "common/heritage.h"
47
48
#include "vcli_serve.h"
49
#include "vsa.h"
50
#include "vtcp.h"
51
#include "vtim.h"
52
53
/*--------------------------------------------------------------------
54
 * We want to get out of any kind of trouble-hit TCP connections as fast
55
 * as absolutely possible, so we set them LINGER disabled, so that even if
56
 * there are outstanding write data on the socket, a close(2) will return
57
 * immediately.
58
 */
59
static const struct linger disable_so_linger = {
60
        .l_onoff        =       0,
61
};
62
63
/*
64
 * We turn on keepalives by default to assist in detecting clients that have
65
 * hung up on connections returning from waitinglists
66
 */
67
static const unsigned enable_so_keepalive = 1;
68
69
/*--------------------------------------------------------------------
70
 * UDS options we want to control
71
 */
72
73
static struct sock_opt sock_opts[] = {
74
        /* Note: Setting the mod counter to something not-zero is needed
75
         * to force the setsockopt() calls on startup */
76
77
        SOCK_OPT(SOL_SOCKET, SO_LINGER, struct linger)
78
        SOCK_OPT(SOL_SOCKET, SO_KEEPALIVE, int)
79
        SOCK_OPT(SOL_SOCKET, SO_SNDTIMEO, struct timeval)
80
        SOCK_OPT(SOL_SOCKET, SO_RCVTIMEO, struct timeval)
81
82
#undef SOCK_OPT
83
};
84
85
static const int n_sock_opts = vcountof(sock_opts);
86
87
/*--------------------------------------------------------------------
88
 * Some kernels have bugs/limitations with respect to which options are
89
 * inherited from the accept/listen socket, so we have to keep track of
90
 * which, if any, sockopts we have to set on the accepted socket.
91
 */
92
93
static int
94
vca_uds_sockopt_init(void)
95 2891
{
96 2891
        struct sock_opt *so;
97 2891
        union sock_arg tmp;
98 2891
        int n, chg = 0;
99 2891
        size_t sz;
100
101 2891
        memset(&tmp, 0, sizeof tmp);
102
103 14455
        for (n = 0; n < n_sock_opts; n++) {
104 11564
                so = &sock_opts[n];
105
106 11564
#define SET_VAL(nm, so, fld, val)                                       \
107 23128
        do {                                                            \
108 23128
                if (!vstrcmp(#nm, so->strname)) {                       \
109 5782
                        assert(so->sz == sizeof so->arg->fld);          \
110 5782
                        so->arg->fld = (val);                           \
111 5782
                }                                                       \
112 23128
        } while (0)
113
114 11564
#define NEW_VAL(nm, so, fld, val)                                       \
115 23128
        do {                                                            \
116 23128
                if (!vstrcmp(#nm, so->strname)) {                       \
117 5782
                        sz = sizeof tmp.fld;                            \
118 5782
                        assert(so->sz == sz);                           \
119 5782
                        tmp.fld = (val);                                \
120 5782
                        if (vmemcmp(&so->arg->fld, &(tmp.fld), sz)) {   \
121 2053
                                vmemcpy(&so->arg->fld, &(tmp.fld), sz); \
122 2053
                                so->mod++;                              \
123 2053
                                chg = 1;                                \
124 2053
                        }                                               \
125 5782
                }                                                       \
126 23128
        } while (0)
127
128 11564
                SET_VAL(SO_LINGER, so, lg, disable_so_linger);
129 11564
                SET_VAL(SO_KEEPALIVE, so, i, enable_so_keepalive);
130 11564
                NEW_VAL(SO_SNDTIMEO, so, tv,
131 11564
                    VTIM_timeval_sock(cache_param->idle_send_timeout));
132 11564
                NEW_VAL(SO_RCVTIMEO, so, tv,
133 11564
                    VTIM_timeval_sock(cache_param->timeout_idle));
134 11564
        }
135
136 2891
        return (chg);
137 2891
}
138
139
static void
140
vca_uds_sockopt_test(const struct listen_sock *ls, const struct sess *sp)
141 29
{
142 29
        struct conn_heritage *ch;
143 29
        struct sock_opt *so;
144 29
        union sock_arg tmp;
145 29
        socklen_t l;
146 29
        int i, n;
147
148 29
        CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
149 29
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
150
151 145
        for (n = 0; n < n_sock_opts; n++) {
152 116
                so = &sock_opts[n];
153 116
                ch = &ls->conn_heritage[n];
154
155 116
                if (ch->sess_set) {
156 0
                        VSL(SLT_Debug, sp->vxid,
157 0
                            "sockopt: Not testing nonhereditary %s for %s=%s",
158 0
                            so->strname, ls->name, ls->endpoint);
159 0
                        continue;
160 0
                }
161
162 116
                memset(&tmp, 0, sizeof tmp);
163 116
                l = so->sz;
164 116
                i = getsockopt(sp->fd, so->level, so->optname, &tmp, &l);
165
166 116
                if (i == 0 && vmemcmp(&tmp, so->arg, so->sz)) {
167 29
                        VSL(SLT_Debug, sp->vxid,
168 29
                            "sockopt: Test confirmed %s non heredity for %s=%s",
169 29
                            so->strname, ls->name, ls->endpoint);
170 29
                        ch->sess_set = 1;
171 29
                }
172
173 116
                if (i && errno != ENOPROTOOPT)
174 116
                        VTCP_Assert(i);
175 116
        }
176 29
}
177
178
static void
179
vca_uds_sockopt_set(const struct listen_sock *ls, const struct sess *sp)
180 388
{
181 388
        struct conn_heritage *ch;
182 388
        struct sock_opt *so;
183 388
        vxid_t vxid;
184 388
        int n, sock;
185
186 388
        CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
187
188 388
        if (sp != NULL) {
189 354
                CHECK_OBJ(sp, SESS_MAGIC);
190 354
                sock = sp->fd;
191 354
                vxid = sp->vxid;
192 354
        } else {
193 34
                sock = ls->sock;
194 34
                vxid = NO_VXID;
195 34
        }
196
197 1940
        for (n = 0; n < n_sock_opts; n++) {
198 1552
                so = &sock_opts[n];
199 1552
                ch = &ls->conn_heritage[n];
200
201 1552
                if (sp == NULL && ch->listen_mod == so->mod) {
202 3
                        VSL(SLT_Debug, vxid,
203 3
                            "sockopt: Not setting unmodified %s for %s=%s",
204 3
                            so->strname, ls->name, ls->endpoint);
205 3
                        continue;
206 3
                }
207
208 1549
                if  (sp != NULL && !ch->sess_set) {
209 1062
                        VSL(SLT_Debug, sp->vxid,
210 1062
                            "sockopt: %s may be inherited for %s=%s",
211 1062
                            so->strname, ls->name, ls->endpoint);
212 1062
                        continue;
213 1062
                }
214
215 487
                VSL(SLT_Debug, vxid,
216 487
                    "sockopt: Setting %s for %s=%s",
217 487
                    so->strname, ls->name, ls->endpoint);
218 487
                VTCP_Assert(setsockopt(sock,
219 487
                    so->level, so->optname, so->arg, so->sz));
220
221 487
                if (sp == NULL)
222 133
                        ch->listen_mod = so->mod;
223 487
        }
224 388
}
225
226
static void
227
vca_uds_init(void)
228 1026
{
229
230 1026
}
231
232
static int
233
vca_uds_listen(struct cli *cli, struct listen_sock *ls)
234 33
{
235
236 33
        CHECK_OBJ_NOTNULL(ls->transport, TRANSPORT_MAGIC);
237 33
        assert (ls->sock > 0);  // We know where stdin is
238
239 33
        if (listen(ls->sock, cache_param->listen_depth)) {
240 0
                VCLI_SetResult(cli, CLIS_CANT);
241 0
                VCLI_Out(cli, "Listen failed on socket '%s': %s",
242 0
                    ls->endpoint, VAS_errtxt(errno));
243 0
                return (-1);
244 0
        }
245
246 33
        AZ(ls->conn_heritage);
247 33
        ls->conn_heritage = calloc(n_sock_opts,
248 33
            sizeof *ls->conn_heritage);
249 33
        AN(ls->conn_heritage);
250
251 33
        ls->test_heritage = 1;
252 33
        vca_uds_sockopt_set(ls, NULL);
253
254 33
        if (cache_param->accept_filter && VTCP_filter_http(ls->sock))
255 32
                VSL(SLT_Error, NO_VXID,
256 32
                    "Kernel filtering: sock=%d, errno=%d %s",
257 32
                    ls->sock, errno, VAS_errtxt(errno));
258
259 33
        return (0);
260 33
}
261
262
static void
263
vca_uds_start(struct cli *cli)
264 1023
{
265 1023
        struct listen_sock *ls;
266
267 1023
        ASSERT_CLI();
268
269 1023
        (void)vca_uds_sockopt_init();
270
271 1023
        VTAILQ_FOREACH(ls, &UDS_acceptor.socks, vcalist) {
272 33
                CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
273
274 33
                if (vca_uds_listen(cli, ls))
275 0
                        return;
276 33
        }
277 1023
}
278
279
static void
280
vca_uds_event(struct cli *cli, struct listen_sock *ls, enum vca_event event)
281 64
{
282
283 64
        (void) ls; // XXX const?
284 64
        switch (event) {
285 64
        case VCA_EVENT_LADDR:
286 64
                CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
287 64
                VCLI_Out(cli, "%s %s -\n", ls->name, ls->endpoint);
288 64
                break;
289 0
        default:
290 0
                WRONG("INVALID VCA_EVENT");
291 64
        }
292 64
}
293
294
static void
295
vca_mk_uds(struct wrk_accept *wa, struct sess *sp)
296 354
{
297 354
        struct suckaddr *sa = NULL;
298 354
        ssize_t sz;
299
300 354
        (void) wa;
301 354
        AN(SES_Reserve_remote_addr(sp, &sa, &sz));
302 354
        AN(sa);
303 354
        assert(sz == vsa_suckaddr_len);
304 354
        AZ(SES_Set_remote_addr(sp, bogo_ip));
305 354
        sp->sattr[SA_CLIENT_ADDR] = sp->sattr[SA_REMOTE_ADDR];
306 354
        sp->sattr[SA_LOCAL_ADDR] = sp->sattr[SA_REMOTE_ADDR];
307 354
        sp->sattr[SA_SERVER_ADDR] = sp->sattr[SA_REMOTE_ADDR];
308 354
        AN(SES_Set_String_Attr(sp, SA_CLIENT_IP, "0.0.0.0"));
309 354
        AN(SES_Set_String_Attr(sp, SA_CLIENT_PORT, "0"));
310 354
}
311
312
static void v_matchproto_(task_func_t)
313
vca_uds_make_session(struct worker *wrk, void *arg)
314 354
{
315 354
        struct wrk_accept *wa;
316 354
        struct sess *sp;
317 354
        struct req *req;
318
319 354
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
320 354
        CAST_OBJ_NOTNULL(wa, arg, WRK_ACCEPT_MAGIC);
321
322 354
        VTCP_blocking(wa->acceptsock);
323
324
        /* Turn accepted socket into a session */
325 354
        AN(WS_Reservation(wrk->aws));
326 354
        sp = SES_New(wrk->pool);
327 354
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
328 354
        wrk->stats->s_sess++;
329
330 354
        sp->t_open = VTIM_real();
331 354
        sp->t_idle = sp->t_open;
332 354
        sp->vxid = VXID_Get(wrk, VSL_CLIENTMARKER);
333
334 354
        sp->fd = wa->acceptsock;
335 354
        wa->acceptsock = -1;
336 354
        sp->listen_sock = wa->acceptlsock;
337
338 354
        assert((size_t)wa->acceptaddrlen <= vsa_suckaddr_len);
339
340 354
        vca_mk_uds(wa, sp);
341
342 354
        AN(wa->acceptlsock->name);
343 354
        VSL(SLT_Begin, sp->vxid, "sess 0 %s",
344 354
            wa->acceptlsock->transport->name);
345 354
        VSL(SLT_SessOpen, sp->vxid, "0.0.0.0 0 %s 0.0.0.0 0 %.6f %d",
346 354
            wa->acceptlsock->name, sp->t_open, sp->fd);
347
348 354
        vca_pace_good();
349 354
        wrk->stats->sess_conn++;
350
351 354
        if (wa->acceptlsock->test_heritage) {
352 29
                vca_uds_sockopt_test(wa->acceptlsock, sp);
353 29
                wa->acceptlsock->test_heritage = 0;
354 29
        }
355
356 354
        vca_uds_sockopt_set(wa->acceptlsock, sp);
357
358 354
        req = Req_New(sp, NULL);
359 354
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
360 354
        req->htc->rfd = &sp->fd;
361
362 354
        SES_SetTransport(wrk, sp, req, wa->acceptlsock->transport);
363 354
        WS_Release(wrk->aws, 0);
364 354
}
365
366
/*--------------------------------------------------------------------
367
 * This function accepts on a single socket for a single thread pool.
368
 *
369
 * As long as we can stick the accepted connection to another thread
370
 * we do so, otherwise we put the socket back on the "BACK" pool
371
 * and handle the new connection ourselves.
372
 */
373
374
static void v_matchproto_(task_func_t)
375
vca_uds_accept_task(struct worker *wrk, void *arg)
376 66
{
377 66
        struct listen_sock *ls;
378 66
        struct wrk_accept wa;
379 66
        struct poolsock *ps;
380 66
        int i;
381
382 66
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
383 66
        CAST_OBJ_NOTNULL(ps, arg, POOLSOCK_MAGIC);
384 66
        ls = ps->lsock;
385 66
        CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
386
387
        /* Return any cached resources from previous task */
388 66
        WRK_Cleanup(wrk);
389
390 130
        while (!pool_accepting && ls->sock != -2 && !ps->pool->die)
391 64
                VTIM_sleep(.1);
392
393 66
        ps->thread = pthread_self();
394 66
        VCA_USR1_Unblock();
395 421
        while (ls->sock != -2 && !ps->pool->die) {
396 419
                INIT_OBJ(&wa, WRK_ACCEPT_MAGIC);
397 419
                wa.acceptlsock = ls;
398
399 419
                vca_pace_check();
400
401 419
                wa.acceptaddrlen = sizeof wa.acceptaddr;
402 419
                do {
403 419
                        i = accept(ls->sock, (void*)&wa.acceptaddr,
404 419
                            &wa.acceptaddrlen);
405 419
                } while (i < 0 && errno == EAGAIN && !ps->pool->die);
406
407 419
                if (i < 0 && (ls->sock == -2 || ps->pool->die))
408 64
                        break;
409
410 355
                if (i < 0) {
411 0
                        switch (errno) {
412 0
                        case ECONNABORTED:
413 0
                                wrk->stats->sess_fail_econnaborted++;
414 0
                                break;
415 0
                        case EINTR:
416 0
                                wrk->stats->sess_fail_eintr++;
417 0
                                break;
418 0
                        case EMFILE:
419 0
                                wrk->stats->sess_fail_emfile++;
420 0
                                vca_pace_bad();
421 0
                                break;
422 0
                        case EBADF:
423 0
                                wrk->stats->sess_fail_ebadf++;
424 0
                                vca_pace_bad();
425 0
                                break;
426 0
                        case ENOBUFS:
427 0
                        case ENOMEM:
428 0
                                wrk->stats->sess_fail_enomem++;
429 0
                                vca_pace_bad();
430 0
                                break;
431 0
                        default:
432 0
                                wrk->stats->sess_fail_other++;
433 0
                                vca_pace_bad();
434 0
                                break;
435 0
                        }
436
437 0
                        i = errno;
438 0
                        wrk->stats->sess_fail++;
439
440 0
                        VSL(SLT_SessError, NO_VXID, "%s 0.0.0.0 0 %d %d \"%s\"",
441 0
                            wa.acceptlsock->name, ls->sock, i, VAS_errtxt(i));
442 0
                        (void)Pool_TrySumstat(wrk);
443 0
                        continue;
444 0
                }
445
446 355
                wa.acceptsock = i;
447
448 355
                if (!Pool_Task_Arg(wrk, TASK_QUEUE_REQ,
449 355
                    vca_uds_make_session, &wa, sizeof wa)) {
450 0
                        ps->thread = cli_thread;
451
                        /*
452
                         * We couldn't get another thread, so we will handle
453
                         * the request in this worker thread, but first we
454
                         * must reschedule the listening task so it will be
455
                         * taken up by another thread again.
456
                         */
457 0
                        if (!ps->pool->die) {
458 0
                                AZ(Pool_Task(wrk->pool, ps->task,
459 0
                                    TASK_QUEUE_VCA));
460 0
                                VCA_USR1_Block();
461 0
                                return;
462 0
                        }
463 0
                }
464 355
                if (!ps->pool->die && DO_DEBUG(DBG_SLOW_ACCEPTOR))
465 0
                        VTIM_sleep(2.0);
466
467 355
        }
468 66
        ps->thread = cli_thread;
469 66
        VCA_USR1_Block();
470
471 66
        VSL(SLT_Debug, NO_VXID, "XXX Accept thread dies %p", ps);
472 66
        Lck_Lock(&ps->pool->mtx);
473 66
        VTAILQ_REMOVE(&ps->pool->poolsocks, ps, list);
474 66
        Lck_Unlock(&ps->pool->mtx);
475 66
        FREE_OBJ(ps);
476 66
}
477
478
static void
479
vca_uds_accept(struct pool *pp)
480 2038
{
481 2038
        struct listen_sock *ls;
482 2038
        struct poolsock *ps;
483
484 2038
        VTAILQ_FOREACH(ls, &UDS_acceptor.socks, vcalist) {
485 66
                CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
486
487 66
                ALLOC_OBJ(ps, POOLSOCK_MAGIC);
488 66
                AN(ps);
489 66
                ps->lsock = ls;
490 66
                ps->task->func = vca_uds_accept_task;
491 66
                ps->task->priv = ps;
492 66
                ps->pool = pp;
493
                // we use cli_thread as a marker for "not accepting"
494 66
                ps->thread = cli_thread;
495 66
                Lck_Lock(&pp->mtx);
496 66
                VTAILQ_INSERT_TAIL(&pp->poolsocks, ps, list);
497 66
                Lck_Unlock(&pp->mtx);
498 66
                AZ(Pool_Task(pp, ps->task, TASK_QUEUE_VCA));
499 66
        }
500 2038
}
501
502
static void
503
vca_uds_update(struct lock *shut_mtx)
504 1868
{
505 1868
        struct listen_sock *ls;
506
507 1868
        if (!vca_uds_sockopt_init())
508 1860
                return;
509
510 8
        Lck_Lock(shut_mtx);
511
512 8
        VTAILQ_FOREACH(ls, &UDS_acceptor.socks, vcalist) {
513 1
                CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
514
515 1
                if (ls->sock == -2)
516 0
                        continue;       // VCA_Shutdown
517 1
                assert (ls->sock > 0);
518 1
                vca_uds_sockopt_set(ls, NULL);
519
                /* If one of the options on a socket has
520
                 * changed, also force a retest of whether
521
                 * the values are inherited to the
522
                 * accepted sockets. This should then
523
                 * catch any false positives from previous
524
                 * tests that could happen if the set
525
                 * value of an option happened to just be
526
                 * the OS default for that value, and
527
                 * wasn't actually inherited from the
528
                 * listening socket. */
529 1
                ls->test_heritage = 1;
530 1
        }
531
532 8
        Lck_Unlock(shut_mtx);
533 8
}
534
535
static void
536
vca_uds_shutdown(void)
537 1013
{
538 1013
        struct listen_sock *ls;
539 1013
        int i;
540
541 1013
        VTAILQ_FOREACH(ls, &UDS_acceptor.socks, vcalist) {
542 32
                CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
543
544 32
                i = ls->sock;
545 32
                ls->sock = -2;
546 32
                (void)close(i);
547 32
        }
548 1013
}
549
550
struct acceptor UDS_acceptor = {
551
        .magic          = ACCEPTOR_MAGIC,
552
        .name           = "uds",
553
        .config         = vca_uds_config,
554
        .init           = vca_uds_init,
555
        .open           = vca_uds_open,
556
        .reopen         = vca_uds_reopen,
557
        .start          = vca_uds_start,
558
        .event          = vca_uds_event,
559
        .accept         = vca_uds_accept,
560
        .update         = vca_uds_update,
561
        .shutdown       = vca_uds_shutdown,
562
};