Code Coverage: vinyl-cache/bin/vinyld/http2/cache_http2_send.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2016 Varnish Software AS
2
 * All rights reserved.
3
 *
4
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
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
31
#include "config.h"
32
33
#include <sys/uio.h>
34
35
#include "cache/cache_int.h"
36
37
#include "cache/cache_transport.h"
38
#include "http2/cache_http2.h"
39
40
#include "vend.h"
41
#include "vtim.h"
42
43
static h2_error
44
h2_errcheck(const struct h2_req *r2, const struct h2_sess *h2)
45 993
{
46 993
        CHECK_OBJ_NOTNULL(r2, H2_REQ_MAGIC);
47 993
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
48
49 993
        if (r2->error != NULL)
50 89
                return (r2->error);
51 904
        if (h2->error != NULL && r2->stream > h2->goaway_last_stream)
52 1
                return (h2->error);
53 903
        return (NULL);
54 904
}
55
56
static int
57
h2_cond_wait(pthread_cond_t *cond, struct h2_sess *h2, struct h2_req *r2)
58 11
{
59 11
        vtim_dur tmo = 0.;
60 11
        vtim_real now;
61 11
        h2_error h2e;
62 11
        int r;
63
64 11
        AN(cond);
65 11
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
66 11
        CHECK_OBJ_NOTNULL(r2, H2_REQ_MAGIC);
67
68 11
        Lck_AssertHeld(&h2->sess->mtx);
69
70 11
        if (cache_param->h2_window_timeout > 0.)
71 11
                tmo = cache_param->h2_window_timeout;
72
73 11
        r = Lck_CondWaitTimeout(cond, &h2->sess->mtx, tmo);
74 11
        assert(r == 0 || r == ETIMEDOUT);
75
76 11
        now = VTIM_real();
77
78
        /* NB: when we grab h2_window_timeout before acquiring the session
79
         * lock we may time out, but once we wake up both send_timeout and
80
         * h2_window_timeout may have changed meanwhile. For this reason
81
         * h2_stream_tmo() may not log what timed out and we need to call
82
         * again with a magic NAN "now" that indicates to h2_stream_tmo()
83
         * that the stream reached the h2_window_timeout via the lock and
84
         * force it to log it.
85
         */
86 11
        h2e = h2_stream_tmo(h2, r2, now, NULL);
87 11
        if (h2e == NULL && r == ETIMEDOUT) {
88 1
                h2e = h2_stream_tmo(h2, r2, NAN, NULL);
89 1
                AN(h2e);
90 1
        }
91
92 11
        if (r2->error == NULL)
93 10
                r2->error = h2e;
94
95 11
        return (h2e != NULL ? -1 : 0);
96 11
}
97
98
static void
99
h2_send_get_locked(struct worker *wrk, struct h2_sess *h2, struct h2_req *r2)
100 917
{
101
102 917
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
103 917
        CHECK_OBJ_NOTNULL(r2, H2_REQ_MAGIC);
104 917
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
105
106 917
        Lck_AssertHeld(&h2->sess->mtx);
107 917
        if (&wrk->cond == h2->cond)
108 417
                ASSERT_RXTHR(h2);
109 917
        AZ(H2_SEND_HELD(h2, r2));
110 917
        AZ(r2->wrk);
111 917
        r2->wrk = wrk;
112 917
        VTAILQ_INSERT_TAIL(&h2->txqueue, r2, tx_list);
113 927
        while (!H2_SEND_HELD(h2, r2))
114 10
                AZ(Lck_CondWait(&wrk->cond, &h2->sess->mtx));
115 917
        r2->wrk = NULL;
116 917
}
117
118
void
119
H2_Send_Get(struct worker *wrk, struct h2_sess *h2, struct h2_req *r2)
120 906
{
121
122 906
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
123 906
        CHECK_OBJ_NOTNULL(r2, H2_REQ_MAGIC);
124 906
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
125
126 906
        Lck_Lock(&h2->sess->mtx);
127 906
        h2_send_get_locked(wrk, h2, r2);
128 906
        Lck_Unlock(&h2->sess->mtx);
129 906
}
130
131
static void
132
h2_send_rel_locked(struct h2_sess *h2, const struct h2_req *r2)
133 917
{
134 917
        CHECK_OBJ_NOTNULL(r2, H2_REQ_MAGIC);
135 917
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
136
137 917
        Lck_AssertHeld(&h2->sess->mtx);
138 917
        AN(H2_SEND_HELD(h2, r2));
139 917
        VTAILQ_REMOVE(&h2->txqueue, r2, tx_list);
140 917
        r2 = VTAILQ_FIRST(&h2->txqueue);
141 917
        if (r2 != NULL) {
142 10
                CHECK_OBJ_NOTNULL(r2->wrk, WORKER_MAGIC);
143 10
                PTOK(pthread_cond_signal(&r2->wrk->cond));
144 10
        }
145 917
}
146
147
void
148
H2_Send_Rel(struct h2_sess *h2, const struct h2_req *r2)
149 906
{
150 906
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
151 906
        CHECK_OBJ_NOTNULL(r2, H2_REQ_MAGIC);
152
153 906
        Lck_Lock(&h2->sess->mtx);
154 906
        h2_send_rel_locked(h2, r2);
155 906
        Lck_Unlock(&h2->sess->mtx);
156 906
}
157
158
static void
159
h2_mk_hdr(uint8_t *hdr, h2_frame ftyp, uint8_t flags,
160
    uint32_t len, uint32_t stream)
161 886
{
162
163 886
        AN(hdr);
164 886
        assert(len < (1U << 24));
165 886
        vbe32enc(hdr, len << 8);
166 886
        hdr[3] = ftyp->type;
167 886
        hdr[4] = flags;
168 886
        vbe32enc(hdr + 5, stream);
169 886
}
170
171
/*
172
 * This is the "raw" frame sender, all per-stream accounting and
173
 * prioritization must have happened before this is called, and
174
 * the session mtx must be held.
175
 */
176
177
void
178
H2_Send_Frame(struct worker *wrk, struct h2_sess *h2,
179
    h2_frame ftyp, uint8_t flags,
180
    uint32_t len, uint32_t stream, const void *ptr)
181 886
{
182 886
        uint8_t hdr[9];
183 886
        ssize_t s;
184 886
        struct iovec iov[2];
185
186 886
        (void)wrk;
187
188 886
        AN(ftyp);
189 886
        AZ(flags & ~(ftyp->flags));
190 886
        if (stream == 0)
191 499
                AZ(ftyp->act_szero);
192 387
        else
193 387
                AZ(ftyp->act_snonzero);
194
195 886
        h2_mk_hdr(hdr, ftyp, flags, len, stream);
196 886
        Lck_Lock(&h2->sess->mtx);
197 886
        VSLb_bin(h2->vsl, SLT_H2TxHdr, 9, hdr);
198 886
        h2->srq->acct.resp_hdrbytes += 9;
199 886
        if (ftyp->overhead)
200 588
                h2->srq->acct.resp_bodybytes += len;
201 886
        Lck_Unlock(&h2->sess->mtx);
202
203 886
        memset(iov, 0, sizeof iov);
204 886
        iov[0].iov_base = (void*)hdr;
205 886
        iov[0].iov_len = sizeof hdr;
206 886
        iov[1].iov_base = TRUST_ME(ptr);
207 886
        iov[1].iov_len = len;
208 886
        s = writev(h2->sess->fd, iov, len == 0 ? 1 : 2);
209 886
        if (s != sizeof hdr + len) {
210 3
                if (errno == EWOULDBLOCK) {
211 0
                        H2S_Lock_VSLb(h2, SLT_SessError,
212 0
                             "H2: stream %u: Hit idle_send_timeout", stream);
213 0
                }
214 3
                else {
215 3
                        H2S_Lock_VSLb(h2, SLT_Debug,
216 3
                            "H2: stream %u: write error s=%zd/%zu errno=%d",
217 3
                            stream, s, sizeof hdr + len, errno);
218 3
                }
219
                /*
220
                 * There is no point in being nice here, we will be unable
221
                 * to send a GOAWAY once the code unrolls, so go directly
222
                 * to the finale and be done with it.
223
                 */
224 3
                h2->error = H2CE_PROTOCOL_ERROR;
225 883
        } else if (len > 0) {
226 704
                Lck_Lock(&h2->sess->mtx);
227 704
                VSLb_bin(h2->vsl, SLT_H2TxBody, len, ptr);
228 704
                Lck_Unlock(&h2->sess->mtx);
229 704
        }
230 886
}
231
232
static int64_t
233
h2_win_limit(const struct h2_req *r2, const struct h2_sess *h2)
234 156
{
235
236 156
        CHECK_OBJ_NOTNULL(r2, H2_REQ_MAGIC);
237 156
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
238 156
        CHECK_OBJ_NOTNULL(h2->req0, H2_REQ_MAGIC);
239
240 156
        Lck_AssertHeld(&h2->sess->mtx);
241 156
        return (vmin_t(int64_t, r2->t_window, h2->req0->t_window));
242 156
}
243
244
static void
245
h2_win_charge(struct h2_req *r2, const struct h2_sess *h2, uint32_t w)
246 156
{
247 156
        CHECK_OBJ_NOTNULL(r2, H2_REQ_MAGIC);
248 156
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
249 156
        CHECK_OBJ_NOTNULL(h2->req0, H2_REQ_MAGIC);
250
251 156
        Lck_AssertHeld(&h2->sess->mtx);
252 156
        r2->t_window -= w;
253 156
        h2->req0->t_window -= w;
254 156
}
255
256
static int64_t
257
h2_do_window(struct worker *wrk, struct h2_req *r2,
258
    struct h2_sess *h2, int64_t wanted)
259 189
{
260 189
        int64_t w = 0;
261
262 189
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
263 189
        CHECK_OBJ_NOTNULL(r2, H2_REQ_MAGIC);
264 189
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
265
266 189
        if (wanted == 0)
267 29
                return (0);
268
269 160
        Lck_Lock(&h2->sess->mtx);
270 160
        if (r2->t_window <= 0 || h2->req0->t_window <= 0) {
271 11
                r2->t_winupd = VTIM_real();
272 11
                h2_send_rel_locked(h2, r2);
273
274 11
                assert(h2->winup_streams >= 0);
275 11
                h2->winup_streams++;
276
277 22
                while (r2->t_window <= 0 && h2_errcheck(r2, h2) == NULL) {
278 11
                        r2->cond = &wrk->cond;
279 11
                        (void)h2_cond_wait(r2->cond, h2, r2);
280 11
                        r2->cond = NULL;
281 11
                }
282
283 11
                while (h2->req0->t_window <= 0 && h2_errcheck(r2, h2) == NULL)
284 0
                        (void)h2_cond_wait(h2->winupd_cond, h2, r2);
285
286 11
                if (h2_errcheck(r2, h2) == NULL) {
287 7
                        w = vmin_t(int64_t, h2_win_limit(r2, h2), wanted);
288 7
                        h2_win_charge(r2, h2, w);
289 7
                        assert (w > 0);
290 7
                }
291
292 11
                if (r2->error == H2SE_BROKE_WINDOW &&
293 11
                    h2->open_streams <= h2->winup_streams) {
294 0
                        VSLb(h2->vsl, SLT_SessError, "H2: window bankrupt");
295 0
                        h2->error = r2->error = H2CE_BANKRUPT;
296 0
                    }
297
298 11
                assert(h2->winup_streams > 0);
299 11
                h2->winup_streams--;
300
301 11
                h2_send_get_locked(wrk, h2, r2);
302 11
        }
303
304 160
        if (w == 0 && h2_errcheck(r2, h2) == NULL) {
305 149
                assert(r2->t_window > 0);
306 149
                assert(h2->req0->t_window > 0);
307 149
                w = h2_win_limit(r2, h2);
308 149
                if (w > wanted)
309 142
                        w = wanted;
310 149
                h2_win_charge(r2, h2, w);
311 149
                assert (w > 0);
312 149
        }
313 160
        r2->t_winupd = 0;
314 160
        Lck_Unlock(&h2->sess->mtx);
315 160
        return (w);
316 160
}
317
318
/*
319
 * This is the per-stream frame sender.
320
 * XXX: priority
321
 */
322
323
static void
324
h2_send(struct worker *wrk, struct h2_req *r2, h2_frame ftyp, uint8_t flags,
325
    uint32_t len, const void *ptr, uint64_t *counter)
326 313
{
327 313
        struct h2_sess *h2;
328 313
        uint32_t mfs, tf;
329 313
        const char *p;
330 313
        uint8_t final_flags;
331
332 313
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
333 313
        CHECK_OBJ_NOTNULL(r2, H2_REQ_MAGIC);
334 313
        h2 = r2->h2sess;
335 313
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
336 313
        assert(len == 0 || ptr != NULL);
337 313
        AN(counter);
338
339 313
        AN(H2_SEND_HELD(h2, r2));
340
341 313
        if (h2_errcheck(r2, h2) != NULL)
342 35
                return;
343
344 278
        AN(ftyp);
345 278
        AZ(flags & ~(ftyp->flags));
346 278
        if (r2->stream == 0)
347 0
                AZ(ftyp->act_szero);
348 278
        else
349 278
                AZ(ftyp->act_snonzero);
350
351 278
        Lck_Lock(&h2->sess->mtx);
352 278
        mfs = h2->remote_settings.max_frame_size;
353 278
        if (r2->counted && (
354 278
            (ftyp == H2_F_HEADERS && (flags & H2FF_HEADERS_END_STREAM)) ||
355 278
            (ftyp == H2_F_DATA && (flags & H2FF_DATA_END_STREAM)) ||
356 278
            ftyp == H2_F_RST_STREAM
357 278
            )) {
358 96
                assert(h2->open_streams > 0);
359 96
                h2->open_streams--;
360 96
                r2->counted = 0;
361 96
        }
362 278
        Lck_Unlock(&h2->sess->mtx);
363
364 278
        if (ftyp->respect_window) {
365 171
                tf = h2_do_window(wrk, r2, h2, (len > mfs) ? mfs : len);
366 171
                if (h2_errcheck(r2, h2) != NULL)
367 0
                        return;
368 171
                AN(H2_SEND_HELD(h2, r2));
369 171
        } else
370 107
                tf = mfs;
371
372 278
        if (len <= tf) {
373 268
                H2_Send_Frame(wrk, h2, ftyp, flags, len, r2->stream, ptr);
374 268
                *counter += len;
375 268
        } else {
376 10
                AN(ptr);
377 10
                p = ptr;
378 10
                final_flags = ftyp->final_flags & flags;
379 10
                flags &= ~ftyp->final_flags;
380 34
                do {
381 34
                        AN(ftyp->continuation);
382 34
                        if (!ftyp->respect_window)
383 8
                                tf = mfs;
384 34
                        if (ftyp->respect_window && p != ptr) {
385 18
                                tf = h2_do_window(wrk, r2, h2,
386 18
                                    (len > mfs) ? mfs : len);
387 18
                                if (h2_errcheck(r2, h2) != NULL)
388 4
                                        return;
389 14
                                AN(H2_SEND_HELD(h2, r2));
390 14
                        }
391 30
                        if (tf < len) {
392 24
                                H2_Send_Frame(wrk, h2, ftyp,
393 24
                                    flags, tf, r2->stream, p);
394 24
                        } else {
395 6
                                if (ftyp->respect_window)
396 4
                                        assert(tf == len);
397 6
                                tf = len;
398 6
                                H2_Send_Frame(wrk, h2, ftyp, final_flags, tf,
399 6
                                    r2->stream, p);
400 6
                                flags = 0;
401 6
                        }
402 30
                        p += tf;
403 30
                        len -= tf;
404 30
                        *counter += tf;
405 30
                        ftyp = ftyp->continuation;
406 30
                        flags &= ftyp->flags;
407 30
                        final_flags &= ftyp->flags;
408 30
                } while (h2->error == NULL && len > 0);
409 10
        }
410 278
}
411
412
void
413
H2_Send_RST(struct worker *wrk, struct h2_sess *h2, const struct h2_req *r2,
414
    uint32_t stream, h2_error h2e)
415 69
{
416 69
        char b[4];
417 69
        h2_error h2e_rr = NULL;
418
419 69
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
420 69
        CHECK_OBJ_NOTNULL(r2, H2_REQ_MAGIC);
421 69
        AN(H2_SEND_HELD(h2, r2));
422 69
        AN(h2e);
423
424 69
        H2S_Lock_VSLb(h2, SLT_Debug, "H2: stream %u: %s", stream, h2e->txt);
425 69
        vbe32enc(b, h2e->val);
426
427 69
        H2_Send_Frame(wrk, h2, H2_F_RST_STREAM, 0, sizeof b, stream, b);
428
429 69
        if (h2_rapid_reset_check(wrk, h2, r2))
430 61
                h2e_rr = h2_rapid_reset_charge(wrk, h2, r2);
431 69
        if (h2e_rr != NULL)
432 1
                h2->error = h2e_rr;
433 69
}
434
435
void
436
H2_Send_GOAWAY(struct worker *wrk, struct h2_sess *h2, const struct h2_req *r2,
437
    h2_error h2e)
438 149
{
439 149
        char b[8];
440
441 149
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
442 149
        CHECK_OBJ_NOTNULL(r2, H2_REQ_MAGIC);
443 149
        AN(H2_SEND_HELD(h2, r2));
444 149
        AN(h2e);
445
446 149
        if (h2->goaway)
447 0
                return;
448
449 149
        vbe32enc(b, h2->highest_stream);
450 149
        vbe32enc(b + 4, h2e->val);
451 149
        H2_Send_Frame(wrk, h2, H2_F_GOAWAY, 0, 8, 0, b);
452 149
        h2->goaway = 1;
453 149
}
454
455
void
456
H2_Send(struct worker *wrk, struct h2_req *r2, h2_frame ftyp, uint8_t flags,
457
    uint32_t len, const void *ptr, uint64_t *counter)
458 313
{
459 313
        uint64_t dummy_counter = 0;
460 313
        h2_error h2e;
461
462 313
        if (counter == NULL)
463 59
                counter = &dummy_counter;
464
465 313
        h2_send(wrk, r2, ftyp, flags, len, ptr, counter);
466
467 313
        h2e = h2_errcheck(r2, r2->h2sess);
468 313
        if (H2_ERROR_MATCH(h2e, H2SE_CANCEL))
469 5
                H2_Send_RST(wrk, r2->h2sess, r2, r2->stream, h2e);
470 313
}