Code Coverage: vinyl-cache/bin/vinyld/acceptor/cache_acceptor_tcp.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_tcp.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
 * TCP options we want to control
55
 */
56
57
static struct sock_opt sock_opts[] = {
58
        /* Note: Setting the mod counter to something not-zero is needed
59
         * to force the setsockopt() calls on startup */
60
61
        SOCK_OPT(SOL_SOCKET, SO_LINGER, struct linger)
62
        SOCK_OPT(SOL_SOCKET, SO_KEEPALIVE, int)
63
        SOCK_OPT(SOL_SOCKET, SO_SNDTIMEO, struct timeval)
64
        SOCK_OPT(SOL_SOCKET, SO_RCVTIMEO, struct timeval)
65
66
        SOCK_OPT(IPPROTO_TCP, TCP_NODELAY, int)
67
68
#if defined(HAVE_TCP_KEEP)
69
        SOCK_OPT(IPPROTO_TCP, TCP_KEEPIDLE, int)
70
        SOCK_OPT(IPPROTO_TCP, TCP_KEEPCNT, int)
71
        SOCK_OPT(IPPROTO_TCP, TCP_KEEPINTVL, int)
72
#elif defined(HAVE_TCP_KEEPALIVE)
73
        SOCK_OPT(IPPROTO_TCP, TCP_KEEPALIVE, int)
74
#endif
75
76
#undef SOCK_OPT
77
};
78
79
static const int n_sock_opts = vcountof(sock_opts);
80
81
/*--------------------------------------------------------------------
82
 * We want to get out of any kind of trouble-hit TCP connections as fast
83
 * as absolutely possible, so we set them LINGER disabled, so that even if
84
 * there are outstanding write data on the socket, a close(2) will return
85
 * immediately.
86
 */
87
static const struct linger disable_so_linger = {
88
        .l_onoff        =       0,
89
};
90
91
/*
92
 * We turn on keepalives by default to assist in detecting clients that have
93
 * hung up on connections returning from waitinglists
94
 */
95
static const unsigned enable_so_keepalive = 1;
96
97
/* We disable Nagle's algorithm in favor of low latency setups.
98
 */
99
static const unsigned enable_tcp_nodelay = 1;
100
101
/*--------------------------------------------------------------------
102
 * Some kernels have bugs/limitations with respect to which options are
103
 * inherited from the accept/listen socket, so we have to keep track of
104
 * which, if any, sockopts we have to set on the accepted socket.
105
 */
106
107
static int
108
vca_tcp_sockopt_init(void)
109 2891
{
110 2891
        struct sock_opt *so;
111 2891
        union sock_arg tmp;
112 2891
        int n, chg = 0;
113 2891
        size_t sz;
114
115 2891
        memset(&tmp, 0, sizeof tmp);
116
117 26019
        for (n = 0; n < n_sock_opts; n++) {
118 23128
                so = &sock_opts[n];
119
120 23128
#define SET_VAL(nm, so, fld, val)                                       \
121 69384
        do {                                                            \
122 69384
                if (!vstrcmp(#nm, so->strname)) {                       \
123 8673
                        assert(so->sz == sizeof so->arg->fld);          \
124 8673
                        so->arg->fld = (val);                           \
125 8673
                }                                                       \
126 69384
        } while (0)
127
128 23128
#define NEW_VAL(nm, so, fld, val)                                       \
129 115640
        do {                                                            \
130 115640
                if (!vstrcmp(#nm, so->strname)) {                       \
131 14455
                        sz = sizeof tmp.fld;                            \
132 14455
                        assert(so->sz == sz);                           \
133 14455
                        tmp.fld = (val);                                \
134 14455
                        if (vmemcmp(&so->arg->fld, &(tmp.fld), sz)) {   \
135 5122
                                vmemcpy(&so->arg->fld, &(tmp.fld), sz); \
136 5122
                                so->mod++;                              \
137 5122
                                chg = 1;                                \
138 5122
                        }                                               \
139 14455
                }                                                       \
140 115640
        } while (0)
141
142 23128
                SET_VAL(SO_LINGER, so, lg, disable_so_linger);
143 23128
                SET_VAL(SO_KEEPALIVE, so, i, enable_so_keepalive);
144 23128
                NEW_VAL(SO_SNDTIMEO, so, tv,
145 23128
                    VTIM_timeval_sock(cache_param->idle_send_timeout));
146 23128
                NEW_VAL(SO_RCVTIMEO, so, tv,
147 23128
                    VTIM_timeval_sock(cache_param->timeout_idle));
148 23128
                SET_VAL(TCP_NODELAY, so, i, enable_tcp_nodelay);
149 23128
#if defined(HAVE_TCP_KEEP)
150 23128
                NEW_VAL(TCP_KEEPIDLE, so, i,
151 23128
                    (int)cache_param->tcp_keepalive_time);
152 23128
                NEW_VAL(TCP_KEEPCNT, so, i,
153 23128
                    (int)cache_param->tcp_keepalive_probes);
154 23128
                NEW_VAL(TCP_KEEPINTVL, so, i,
155 23128
                    (int)cache_param->tcp_keepalive_intvl);
156
#elif defined(HAVE_TCP_KEEPALIVE)
157
                NEW_VAL(TCP_KEEPALIVE, so, i,
158
                    (int)cache_param->tcp_keepalive_time);
159
#endif
160 23128
        }
161
162 2891
        return (chg);
163 2891
}
164
165
static void
166
vca_tcp_sockopt_test(const struct listen_sock *ls, const struct sess *sp)
167 929
{
168 929
        struct conn_heritage *ch;
169 929
        struct sock_opt *so;
170 929
        union sock_arg tmp;
171 929
        socklen_t l;
172 929
        int i, n;
173
174 929
        CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
175 929
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
176
177 8359
        for (n = 0; n < n_sock_opts; n++) {
178 7430
                so = &sock_opts[n];
179 7430
                ch = &ls->conn_heritage[n];
180
181 7430
                if (ch->sess_set) {
182 39
                        VSL(SLT_Debug, sp->vxid,
183 39
                            "sockopt: Not testing nonhereditary %s for %s=%s",
184 39
                            so->strname, ls->name, ls->endpoint);
185 39
                        continue;
186 39
                }
187
188 7391
                memset(&tmp, 0, sizeof tmp);
189 7391
                l = so->sz;
190 7391
                i = getsockopt(sp->fd, so->level, so->optname, &tmp, &l);
191
192 7393
                if (i == 0 && vmemcmp(&tmp, so->arg, so->sz)) {
193 1819
                        VSL(SLT_Debug, sp->vxid,
194 1819
                            "sockopt: Test confirmed %s non heredity for %s=%s",
195 1819
                            so->strname, ls->name, ls->endpoint);
196 1819
                        ch->sess_set = 1;
197 1819
                }
198
199 7391
                if (i && errno != ENOPROTOOPT)
200 7391
                        VTCP_Assert(i);
201 7391
        }
202 929
}
203
204
static void
205
vca_tcp_sockopt_set(const struct listen_sock *ls, const struct sess *sp)
206 3044
{
207 3044
        struct conn_heritage *ch;
208 3044
        struct sock_opt *so;
209 3044
        vxid_t vxid;
210 3044
        int n, sock;
211
212 3044
        CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
213
214 3044
        if (sp != NULL) {
215 2041
                CHECK_OBJ(sp, SESS_MAGIC);
216 2041
                sock = sp->fd;
217 2041
                vxid = sp->vxid;
218 2041
        } else {
219 1003
                sock = ls->sock;
220 1003
                vxid = NO_VXID;
221 1003
        }
222
223 27393
        for (n = 0; n < n_sock_opts; n++) {
224 24349
                so = &sock_opts[n];
225 24349
                ch = &ls->conn_heritage[n];
226
227 24349
                if (sp == NULL && ch->listen_mod == so->mod) {
228 28
                        VSL(SLT_Debug, vxid,
229 28
                            "sockopt: Not setting unmodified %s for %s=%s",
230 28
                            so->strname, ls->name, ls->endpoint);
231 28
                        continue;
232 28
                }
233
234 24321
                if  (sp != NULL && !ch->sess_set) {
235 12245
                        VSL(SLT_Debug, sp->vxid,
236 12245
                            "sockopt: %s may be inherited for %s=%s",
237 12245
                            so->strname, ls->name, ls->endpoint);
238 12245
                        continue;
239 12245
                }
240
241 12076
                VSL(SLT_Debug, vxid,
242 12076
                    "sockopt: Setting %s for %s=%s",
243 12076
                    so->strname, ls->name, ls->endpoint);
244 12076
                VTCP_Assert(setsockopt(sock,
245 12076
                    so->level, so->optname, so->arg, so->sz));
246
247 12076
                if (sp == NULL)
248 7996
                        ch->listen_mod = so->mod;
249 12076
        }
250 3044
}
251
252
static void
253
vca_tcp_init(void)
254 1026
{
255
256 1026
}
257
258
static int
259
vca_tcp_listen(struct cli *cli, struct listen_sock *ls)
260 999
{
261
262 999
        CHECK_OBJ_NOTNULL(ls->transport, TRANSPORT_MAGIC);
263 999
        assert (ls->sock > 0);  // We know where stdin is
264
265 999
        if (cache_param->tcp_fastopen &&
266 999
            VTCP_fastopen(ls->sock, cache_param->listen_depth))
267 0
                VSL(SLT_Error, NO_VXID,
268 0
                    "Kernel TCP Fast Open: sock=%d, errno=%d %s",
269 0
                    ls->sock, errno, VAS_errtxt(errno));
270
271 999
        if (listen(ls->sock, cache_param->listen_depth)) {
272 0
                VCLI_SetResult(cli, CLIS_CANT);
273 0
                VCLI_Out(cli, "Listen failed on socket '%s': %s",
274 0
                    ls->endpoint, VAS_errtxt(errno));
275 0
                return (-1);
276 0
        }
277
278 999
        AZ(ls->conn_heritage);
279 999
        ls->conn_heritage = calloc(n_sock_opts,
280 999
            sizeof *ls->conn_heritage);
281 999
        AN(ls->conn_heritage);
282
283 999
        ls->test_heritage = 1;
284 999
        vca_tcp_sockopt_set(ls, NULL);
285
286 999
        if (cache_param->accept_filter && VTCP_filter_http(ls->sock))
287 994
                VSL(SLT_Error, NO_VXID,
288 994
                    "Kernel filtering: sock=%d, errno=%d %s",
289 994
                    ls->sock, errno, VAS_errtxt(errno));
290
291 999
        return (0);
292 999
}
293
294
static void
295
vca_tcp_start(struct cli *cli)
296 1023
{
297 1023
        struct listen_sock *ls;
298
299 1023
        ASSERT_CLI();
300
301 1023
        (void)vca_tcp_sockopt_init();
302
303 1023
        VTAILQ_FOREACH(ls, &TCP_acceptor.socks, vcalist) {
304 999
                CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
305
306 999
                if (vca_tcp_listen(cli, ls))
307 0
                        return;
308 999
        }
309 1023
}
310
311
static void
312
vca_tcp_event(struct cli *cli, struct listen_sock *ls, enum vca_event event)
313 1977
{
314 1977
        char h[VTCP_ADDRBUFSIZE], p[VTCP_PORTBUFSIZE];
315
316 1977
        (void) ls; // XXX const?
317 1977
        switch (event) {
318 1977
        case VCA_EVENT_LADDR:
319 1977
                VTCP_myname(ls->sock, h, sizeof h, p, sizeof p);
320 1977
                VCLI_Out(cli, "%s %s %s\n", ls->name, h, p);
321 1977
                break;
322 0
        default:
323 0
                WRONG("INVALID VCA_EVENT");
324 1977
        }
325 1977
}
326
327
/*--------------------------------------------------------------------
328
 * The pool-task for a newly accepted session
329
 *
330
 * Called from assigned worker thread
331
 */
332
333
static void
334
vca_mk_tcp(const struct wrk_accept *wa,
335
    struct sess *sp, char *laddr, char *lport, char *raddr, char *rport)
336 2041
{
337 2041
        struct suckaddr *sa = NULL;
338 2041
        ssize_t sz;
339
340 2041
        AN(SES_Reserve_remote_addr(sp, &sa, &sz));
341 2041
        AN(sa);
342 2041
        assert(sz == vsa_suckaddr_len);
343 2041
        AN(VSA_Build(sa, &wa->acceptaddr, wa->acceptaddrlen));
344 2041
        sp->sattr[SA_CLIENT_ADDR] = sp->sattr[SA_REMOTE_ADDR];
345
346 2041
        VTCP_name(sa, raddr, VTCP_ADDRBUFSIZE, rport, VTCP_PORTBUFSIZE);
347 2041
        AN(SES_Set_String_Attr(sp, SA_CLIENT_IP, raddr));
348 2041
        AN(SES_Set_String_Attr(sp, SA_CLIENT_PORT, rport));
349
350
351 2041
        AN(SES_Reserve_local_addr(sp, &sa, &sz));
352 2041
        AN(VSA_getsockname(sp->fd, sa, sz));
353 2041
        sp->sattr[SA_SERVER_ADDR] = sp->sattr[SA_LOCAL_ADDR];
354 2041
        VTCP_name(sa, laddr, VTCP_ADDRBUFSIZE, lport, VTCP_PORTBUFSIZE);
355 2041
}
356
357
static void v_matchproto_(task_func_t)
358
vca_tcp_make_session(struct worker *wrk, void *arg)
359 2041
{
360 2041
        char laddr[VTCP_ADDRBUFSIZE];
361 2041
        char lport[VTCP_PORTBUFSIZE];
362 2041
        char raddr[VTCP_ADDRBUFSIZE];
363 2041
        char rport[VTCP_PORTBUFSIZE];
364 2041
        struct wrk_accept *wa;
365 2041
        struct sess *sp;
366 2041
        struct req *req;
367
368 2041
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
369 2041
        CAST_OBJ_NOTNULL(wa, arg, WRK_ACCEPT_MAGIC);
370
371 2041
        VTCP_blocking(wa->acceptsock);
372
373
        /* Turn accepted socket into a session */
374 2041
        AN(WS_Reservation(wrk->aws));
375 2041
        sp = SES_New(wrk->pool);
376 2041
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
377 2041
        wrk->stats->s_sess++;
378
379 2041
        sp->t_open = VTIM_real();
380 2041
        sp->t_idle = sp->t_open;
381 2041
        sp->vxid = VXID_Get(wrk, VSL_CLIENTMARKER);
382
383 2041
        sp->fd = wa->acceptsock;
384 2041
        wa->acceptsock = -1;
385 2041
        sp->listen_sock = wa->acceptlsock;
386
387 2041
        assert((size_t)wa->acceptaddrlen <= vsa_suckaddr_len);
388
389 2041
        vca_mk_tcp(wa, sp, laddr, lport, raddr, rport);
390
391 2041
        AN(wa->acceptlsock->name);
392 2041
        VSL(SLT_Begin, sp->vxid, "sess 0 %s",
393 2041
            wa->acceptlsock->transport->name);
394 2041
        VSL(SLT_SessOpen, sp->vxid, "%s %s %s %s %s %.6f %d",
395 2041
            raddr, rport, wa->acceptlsock->name, laddr, lport,
396 2041
            sp->t_open, sp->fd);
397
398 2041
        vca_pace_good();
399 2041
        wrk->stats->sess_conn++;
400
401 2041
        if (wa->acceptlsock->test_heritage) {
402 929
                vca_tcp_sockopt_test(wa->acceptlsock, sp);
403 929
                wa->acceptlsock->test_heritage = 0;
404 929
        }
405
406 2041
        vca_tcp_sockopt_set(wa->acceptlsock, sp);
407
408 2041
        req = Req_New(sp, NULL);
409 2041
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
410 2041
        req->htc->rfd = &sp->fd;
411
412 2041
        SES_SetTransport(wrk, sp, req, wa->acceptlsock->transport);
413 2041
        WS_Release(wrk->aws, 0);
414 2041
}
415
416
/*--------------------------------------------------------------------
417
 * This function accepts on a single socket for a single thread pool.
418
 *
419
 * As long as we can stick the accepted connection to another thread
420
 * we do so, otherwise we put the socket back on the "BACK" pool
421
 * and handle the new connection ourselves.
422
 */
423
424
static void v_matchproto_(task_func_t)
425
vca_tcp_accept_task(struct worker *wrk, void *arg)
426 1994
{
427 1994
        char laddr[VTCP_ADDRBUFSIZE];
428 1994
        char lport[VTCP_PORTBUFSIZE];
429 1994
        struct listen_sock *ls;
430 1994
        struct wrk_accept wa;
431 1994
        struct poolsock *ps;
432 1994
        int i;
433
434 1994
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
435 1994
        CAST_OBJ_NOTNULL(ps, arg, POOLSOCK_MAGIC);
436 1994
        ls = ps->lsock;
437 1994
        CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
438 1994
        CHECK_OBJ_NOTNULL(ps->pool, POOL_MAGIC);
439
440
        /* Return any cached resources from previous task */
441 1994
        WRK_Cleanup(wrk);
442
443 4150
        while (!pool_accepting && ls->sock != -2 && !ps->pool->die)
444 2156
                VTIM_sleep(.1);
445
446 1994
        ps->thread = pthread_self();
447 1994
        VCA_USR1_Unblock();
448 4050
        while (ls->sock != -2 && !ps->pool->die) {
449 4019
                INIT_OBJ(&wa, WRK_ACCEPT_MAGIC);
450 4019
                wa.acceptlsock = ls;
451
452 4019
                vca_pace_check();
453
454 4019
                wa.acceptaddrlen = sizeof wa.acceptaddr;
455 4019
                do {
456 4019
                        i = accept(ls->sock, (void*)&wa.acceptaddr,
457 4019
                            &wa.acceptaddrlen);
458 4019
                } while (i < 0 && errno == EAGAIN && !ps->pool->die);
459
460 4019
                if (i < 0 && (ls->sock == -2 || ps->pool->die))
461 1961
                        break;
462
463 2058
                if (i < 0) {
464 0
                        switch (errno) {
465 0
                        case ECONNABORTED:
466 0
                                wrk->stats->sess_fail_econnaborted++;
467 0
                                break;
468 0
                        case EINTR:
469 0
                                wrk->stats->sess_fail_eintr++;
470 0
                                break;
471 0
                        case EMFILE:
472 0
                                wrk->stats->sess_fail_emfile++;
473 0
                                vca_pace_bad();
474 0
                                break;
475 0
                        case EBADF:
476 0
                                wrk->stats->sess_fail_ebadf++;
477 0
                                vca_pace_bad();
478 0
                                break;
479 0
                        case ENOBUFS:
480 0
                        case ENOMEM:
481 0
                                wrk->stats->sess_fail_enomem++;
482 0
                                vca_pace_bad();
483 0
                                break;
484 0
                        default:
485 0
                                wrk->stats->sess_fail_other++;
486 0
                                vca_pace_bad();
487 0
                                break;
488 0
                        }
489
490 0
                        i = errno;
491 0
                        wrk->stats->sess_fail++;
492
493 0
                        VTCP_myname(ls->sock, laddr, VTCP_ADDRBUFSIZE,
494 0
                            lport, VTCP_PORTBUFSIZE);
495
496 0
                        VSL(SLT_SessError, NO_VXID, "%s %s %s %d %d \"%s\"",
497 0
                            wa.acceptlsock->name, laddr, lport,
498 0
                            ls->sock, i, VAS_errtxt(i));
499 0
                        (void)Pool_TrySumstat(wrk);
500 0
                        continue;
501 0
                }
502
503 2058
                wa.acceptsock = i;
504
505 2058
                if (!Pool_Task_Arg(wrk, TASK_QUEUE_REQ,
506 2058
                    vca_tcp_make_session, &wa, sizeof wa)) {
507 2
                        ps->thread = cli_thread;
508
                        /*
509
                         * We couldn't get another thread, so we will handle
510
                         * the request in this worker thread, but first we
511
                         * must reschedule the listening task so it will be
512
                         * taken up by another thread again.
513
                         */
514 2
                        if (!ps->pool->die) {
515 2
                                AZ(Pool_Task(wrk->pool, ps->task,
516 2
                                    TASK_QUEUE_VCA));
517 2
                                VCA_USR1_Block();
518 2
                                return;
519 2
                        }
520 2
                }
521 2056
                if (!ps->pool->die && DO_DEBUG(DBG_SLOW_ACCEPTOR))
522 8
                        VTIM_sleep(2.0);
523
524 2056
        }
525 1992
        ps->thread = cli_thread;
526 1992
        VCA_USR1_Block();
527
528 1992
        VSL(SLT_Debug, NO_VXID, "XXX Accept thread dies %p", ps);
529 1992
        Lck_Lock(&ps->pool->mtx);
530 1992
        VTAILQ_REMOVE(&ps->pool->poolsocks, ps, list);
531 1992
        Lck_Unlock(&ps->pool->mtx);
532 1992
        FREE_OBJ(ps);
533 1992
}
534
535
static void
536
vca_tcp_accept(struct pool *pp)
537 2038
{
538 2038
        struct listen_sock *ls;
539 2038
        struct poolsock *ps;
540
541 2038
        VTAILQ_FOREACH(ls, &TCP_acceptor.socks, vcalist) {
542 1992
                CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
543
544 1992
                ALLOC_OBJ(ps, POOLSOCK_MAGIC);
545 1992
                AN(ps);
546 1992
                ps->lsock = ls;
547 1992
                ps->task->func = vca_tcp_accept_task;
548 1992
                ps->task->priv = ps;
549 1992
                ps->pool = pp;
550
                // we use cli_thread as a marker for "not accepting"
551 1992
                ps->thread = cli_thread;
552 1992
                Lck_Lock(&pp->mtx);
553 1992
                VTAILQ_INSERT_TAIL(&pp->poolsocks, ps, list);
554 1992
                Lck_Unlock(&pp->mtx);
555 1992
                AZ(Pool_Task(pp, ps->task, TASK_QUEUE_VCA));
556 1992
        }
557 2038
}
558
559
static void
560
vca_tcp_update(struct lock *shut_mtx)
561 1868
{
562 1868
        struct listen_sock *ls;
563
564 1868
        if (!vca_tcp_sockopt_init())
565 1860
                return;
566
567 8
        Lck_Lock(shut_mtx);
568
569 8
        VTAILQ_FOREACH(ls, &TCP_acceptor.socks, vcalist) {
570 7
                CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
571
572 7
                if (ls->sock == -2)
573 3
                        continue;       // VCA_Shutdown
574 4
                assert (ls->sock > 0);
575 4
                vca_tcp_sockopt_set(ls, NULL);
576
                /* If one of the options on a socket has
577
                 * changed, also force a retest of whether
578
                 * the values are inherited to the
579
                 * accepted sockets. This should then
580
                 * catch any false positives from previous
581
                 * tests that could happen if the set
582
                 * value of an option happened to just be
583
                 * the OS default for that value, and
584
                 * wasn't actually inherited from the
585
                 * listening socket. */
586 4
                ls->test_heritage = 1;
587 4
        }
588
589 8
        Lck_Unlock(shut_mtx);
590 8
}
591
592
static void
593
vca_tcp_shutdown(void)
594 1013
{
595 1013
        struct listen_sock *ls;
596 1013
        int i;
597
598 1013
        VTAILQ_FOREACH(ls, &TCP_acceptor.socks, vcalist) {
599 989
                CHECK_OBJ_NOTNULL(ls, LISTEN_SOCK_MAGIC);
600
601 989
                i = ls->sock;
602 989
                ls->sock = -2;
603 989
                (void)close(i);
604 989
        }
605 1013
}
606
607
struct acceptor TCP_acceptor = {
608
        .magic          = ACCEPTOR_MAGIC,
609
        .name           = "tcp",
610
        .config         = vca_tcp_config,
611
        .init           = vca_tcp_init,
612
        .open           = vca_tcp_open,
613
        .reopen         = vca_tcp_reopen,
614
        .start          = vca_tcp_start,
615
        .event          = vca_tcp_event,
616
        .accept         = vca_tcp_accept,
617
        .update         = vca_tcp_update,
618
        .shutdown       = vca_tcp_shutdown,
619
};