Code Coverage: vinyl-cache/bin/vinyld/cache/cache_fetch_proc.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
#include "config.h"
32
33
#include <stdlib.h>
34
35
#include "cache_int.h"
36
#include "cache_filter.h"
37
38
/*--------------------------------------------------------------------
39
 * We want to issue the first error we encounter on fetching and
40
 * suppress the rest.  This function does that.
41
 *
42
 * Other code is allowed to look at busyobj->fetch_failed to bail out
43
 *
44
 * For convenience, always return VFP_ERROR
45
 */
46
47
enum vfp_status
48
VFP_Error(struct vfp_ctx *vc, const char *fmt, ...)
49 275
{
50 275
        va_list ap;
51
52 275
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
53 275
        if (!vc->failed) {
54 169
                va_start(ap, fmt);
55 169
                VSLbv(vc->wrk->vsl, SLT_FetchError, fmt, ap);
56 169
                va_end(ap);
57 169
                vc->failed = 1;
58 169
        }
59 275
        return (VFP_ERROR);
60 275
}
61
62
/*--------------------------------------------------------------------
63
 * Fetch Storage to put object into.
64
 *
65
 */
66
67
enum vfp_status
68
VFP_GetStorage(struct vfp_ctx *vc, ssize_t *sz, uint8_t **ptr)
69 63381
{
70
71 63381
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
72 63381
        AN(sz);
73 63381
        assert(*sz >= 0);
74 63381
        AN(ptr);
75
76 63381
        if (!ObjGetSpace(vc->wrk, vc->oc, sz, ptr)) {
77 8
                *sz = 0;
78 8
                *ptr = NULL;
79 8
                return (VFP_Error(vc, "Could not get storage"));
80 8
        }
81 63373
        assert(*sz > 0);
82 63373
        AN(*ptr);
83 63373
        return (VFP_OK);
84 63373
}
85
86
void
87
VFP_Extend(const struct vfp_ctx *vc, ssize_t sz, enum vfp_status flg)
88 60423
{
89 60423
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
90
91 60423
        ObjExtend(vc->wrk, vc->oc, sz, flg == VFP_END ? 1 : 0);
92 60423
}
93
94
/**********************************************************************
95
 */
96
97
void
98
VFP_Setup(struct vfp_ctx *vc, struct worker *wrk)
99 3272
{
100
101 3272
        INIT_OBJ(vc, VFP_CTX_MAGIC);
102 3272
        VTAILQ_INIT(&vc->vfp);
103 3272
        vc->wrk = wrk;
104 3272
}
105
106
/**********************************************************************
107
 * Returns the number of bytes processed by the lowest VFP in the stack
108
 */
109
110
uint64_t
111
VFP_Close(struct vfp_ctx *vc)
112 3028
{
113 3028
        struct vfp_entry *vfe, *tmp;
114 3028
        uint64_t rv = 0;
115
116 3028
        VTAILQ_FOREACH_SAFE(vfe, &vc->vfp, list, tmp) {
117 2944
                if (vfe->vfp->fini != NULL)
118 921
                        vfe->vfp->fini(vc, vfe);
119 2944
                rv = vfe->bytes_out;
120 2944
                VSLb(vc->wrk->vsl, SLT_VfpAcct, "%s %ju %ju", vfe->vfp->name,
121 2944
                    (uintmax_t)vfe->calls, (uintmax_t)rv);
122 2944
                VTAILQ_REMOVE(&vc->vfp, vfe, list);
123 2944
        }
124 3028
        return (rv);
125 3028
}
126
127
int
128
VFP_Open(VRT_CTX, struct vfp_ctx *vc)
129 2850
{
130 2850
        struct vfp_entry *vfe;
131
132 2850
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
133 2850
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
134 2850
        CHECK_OBJ_NOTNULL(vc->resp, HTTP_MAGIC);
135 2850
        CHECK_OBJ_NOTNULL(vc->wrk, WORKER_MAGIC);
136 2850
        AN(vc->wrk->vsl);
137
138 2888
        VTAILQ_FOREACH_REVERSE(vfe, &vc->vfp, vfp_entry_s, list) {
139 2888
                if (vfe->vfp->init == NULL)
140 2004
                        continue;
141 884
                if (DO_DEBUG(DBG_PROCESSORS))
142 1
                        VSLb(vc->wrk->vsl, SLT_Debug, "VFP_Open(%s)",
143 1
                             vfe->vfp->name);
144 884
                vfe->closed = vfe->vfp->init(ctx, vc, vfe);
145 884
                if (vfe->closed != VFP_OK && vfe->closed != VFP_NULL) {
146 53
                        (void)VFP_Error(vc, "Fetch filter %s failed to open",
147 53
                            vfe->vfp->name);
148 53
                        (void)VFP_Close(vc);
149 53
                        return (-1);
150 53
                }
151 884
        }
152
153 2797
        return (0);
154 2850
}
155
156
/**********************************************************************
157
 * Suck data up from lower levels.
158
 * Once a layer return non VFP_OK, clean it up and produce the same
159
 * return value for any subsequent calls.
160
 */
161
162
enum vfp_status
163
VFP_Suck(struct vfp_ctx *vc, void *p, ssize_t *lp)
164 113428
{
165 113428
        enum vfp_status vp;
166 113428
        struct vfp_entry *vfe, *vfe_prev;
167 113428
        const char *prev_name = "<storage>";
168 113428
        ssize_t limit;
169
170 113428
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
171 113428
        AN(p);
172 113428
        AN(lp);
173 113428
        limit = *lp;
174 113428
        vfe = vc->vfp_nxt;
175 113428
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
176 113428
        vc->vfp_nxt = VTAILQ_NEXT(vfe, list);
177
178 113428
        vfe_prev = VTAILQ_PREV(vfe, vfp_entry_s, list);
179 113428
        if (vfe_prev != NULL)
180 54602
                prev_name = vfe_prev->vfp->name;
181
182 113428
        if (vfe->closed == VFP_NULL) {
183
                /* Layer asked to be bypassed when opened */
184 4
                vp = VFP_Suck(vc, p, lp);
185 4
                VFP_DEBUG(vc, "bypassing %s vp=%d", vfe->vfp->name, vp);
186 113424
        } else if (vfe->closed == VFP_OK) {
187 113285
                vp = vfe->vfp->pull(vc, vfe, p, lp);
188 113285
                VFP_DEBUG(vc, "%s pulled %zdB/%zdB from %s vp=%d",
189 113285
                    prev_name, *lp, limit, vfe->vfp->name, vp);
190 113285
                if (vp != VFP_OK && vp != VFP_END && vp != VFP_ERROR)
191 0
                        vp = VFP_Error(vc, "Fetch filter %s returned %d",
192 0
                            vfe->vfp->name, vp);
193 113285
                else
194 113285
                        vfe->bytes_out += *lp;
195 113285
                vfe->closed = vp;
196 113285
                vfe->calls++;
197 113285
        } else {
198
                /* Already closed filter */
199 139
                *lp = 0;
200 139
                vp = vfe->closed;
201 139
                VFP_DEBUG(vc, "ignoring %s vp=%d", vfe->vfp->name, vp);
202 139
        }
203 0
        vc->vfp_nxt = vfe;
204 113428
        assert(vp != VFP_NULL);
205 113428
        return (vp);
206 113428
}
207
208
/*--------------------------------------------------------------------
209
 */
210
211
struct vfp_entry *
212
VFP_Push(struct vfp_ctx *vc, const struct vfp *vfp)
213 3000
{
214 3000
        struct vfp_entry *vfe;
215
216 3000
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
217 3000
        CHECK_OBJ_NOTNULL(vc->resp, HTTP_MAGIC);
218
219 3000
        vfe = WS_Alloc(vc->resp->ws, sizeof *vfe);
220 3000
        if (vfe == NULL) {
221 38
                (void)VFP_Error(vc, "Workspace overflow");
222 38
                return (NULL);
223 38
        }
224
225 2962
        INIT_OBJ(vfe, VFP_ENTRY_MAGIC);
226 2962
        vfe->vfp = vfp;
227 2962
        vfe->closed = VFP_OK;
228
        VTAILQ_INSERT_HEAD(&vc->vfp, vfe, list);
229 2962
        vc->vfp_nxt = vfe;
230 2962
        return (vfe);
231 3000
}