GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "config.h"

#include <stdlib.h>

#include "cache_varnishd.h"
#include "cache_filter.h"
#include "vcli_serve.h"

static unsigned fetchfrag;

/*--------------------------------------------------------------------
 * We want to issue the first error we encounter on fetching and
 * suppress the rest.  This function does that.
 *
 * Other code is allowed to look at busyobj->fetch_failed to bail out
 *
 * For convenience, always return VFP_ERROR
 */

enum vfp_status
VFP_Error(struct vfp_ctx *vc, const char *fmt, ...)
{
        va_list ap;

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        if (!vc->failed) {
                va_start(ap, fmt);
                VSLbv(vc->wrk->vsl, SLT_FetchError, fmt, ap);
                va_end(ap);
                vc->failed = 1;
        }
        return (VFP_ERROR);
}

/*--------------------------------------------------------------------
 * Fetch Storage to put object into.
 *
 */

enum vfp_status
VFP_GetStorage(struct vfp_ctx *vc, ssize_t *sz, uint8_t **ptr)
{

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        AN(sz);
        assert(*sz >= 0);
        AN(ptr);

        if (fetchfrag > 0)
                *sz = fetchfrag;

        if (!ObjGetSpace(vc->wrk, vc->oc, sz, ptr)) {
                *sz = 0;
                *ptr = NULL;
                return (VFP_Error(vc, "Could not get storage"));
        }
        assert(*sz > 0);
        AN(*ptr);
        return (VFP_OK);
}

void
VFP_Extend(const struct vfp_ctx *vc, ssize_t sz, enum vfp_status flg)
{
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);

        ObjExtend(vc->wrk, vc->oc, sz, flg == VFP_END ? 1 : 0);
}

/**********************************************************************
 */

void
VFP_Setup(struct vfp_ctx *vc, struct worker *wrk)
{

        INIT_OBJ(vc, VFP_CTX_MAGIC);
        VTAILQ_INIT(&vc->vfp);
        vc->wrk = wrk;
}

/**********************************************************************
 * Returns the number of bytes processed by the lowest VFP in the stack
 */

uint64_t
VFP_Close(struct vfp_ctx *vc)
{
        struct vfp_entry *vfe, *tmp;
        uint64_t rv = 0;

        VTAILQ_FOREACH_SAFE(vfe, &vc->vfp, list, tmp) {
                if (vfe->vfp->fini != NULL)
                        vfe->vfp->fini(vc, vfe);
                rv = vfe->bytes_out;
                VSLb(vc->wrk->vsl, SLT_VfpAcct, "%s %ju %ju", vfe->vfp->name,
                    (uintmax_t)vfe->calls, (uintmax_t)rv);
                VTAILQ_REMOVE(&vc->vfp, vfe, list);
        }
        return (rv);
}

int
VFP_Open(VRT_CTX, struct vfp_ctx *vc)
{
        struct vfp_entry *vfe;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vc->resp, HTTP_MAGIC);
        CHECK_OBJ_NOTNULL(vc->wrk, WORKER_MAGIC);
        AN(vc->wrk->vsl);

        VTAILQ_FOREACH_REVERSE(vfe, &vc->vfp, vfp_entry_s, list) {
                if (vfe->vfp->init == NULL)
                        continue;
                if (DO_DEBUG(DBG_PROCESSORS))
                        VSLb(vc->wrk->vsl, SLT_Debug, "VFP_Open(%s)",
                             vfe->vfp->name);
                vfe->closed = vfe->vfp->init(ctx, vc, vfe);
                if (vfe->closed != VFP_OK && vfe->closed != VFP_NULL) {
                        (void)VFP_Error(vc, "Fetch filter %s failed to open",
                            vfe->vfp->name);
                        (void)VFP_Close(vc);
                        return (-1);
                }
        }

        return (0);
}

/**********************************************************************
 * Suck data up from lower levels.
 * Once a layer return non VFP_OK, clean it up and produce the same
 * return value for any subsequent calls.
 */

enum vfp_status
VFP_Suck(struct vfp_ctx *vc, void *p, ssize_t *lp)
{
        enum vfp_status vp;
        struct vfp_entry *vfe;

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        AN(p);
        AN(lp);
        vfe = vc->vfp_nxt;
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
        vc->vfp_nxt = VTAILQ_NEXT(vfe, list);

        if (vfe->closed == VFP_NULL) {
                /* Layer asked to be bypassed when opened */
                vp = VFP_Suck(vc, p, lp);
        } else if (vfe->closed == VFP_OK) {
                vp = vfe->vfp->pull(vc, vfe, p, lp);
                if (vp != VFP_OK && vp != VFP_END && vp != VFP_ERROR)
                        vp = VFP_Error(vc, "Fetch filter %s returned %d",
                            vfe->vfp->name, vp);
                else
                        vfe->bytes_out += *lp;
                vfe->closed = vp;
                vfe->calls++;
        } else {
                /* Already closed filter */
                *lp = 0;
                vp = vfe->closed;
        }
        vc->vfp_nxt = vfe;
        assert(vp != VFP_NULL);
        return (vp);
}

/*--------------------------------------------------------------------
 */

struct vfp_entry *
VFP_Push(struct vfp_ctx *vc, const struct vfp *vfp)
{
        struct vfp_entry *vfe;

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vc->resp, HTTP_MAGIC);

        vfe = WS_Alloc(vc->resp->ws, sizeof *vfe);
        if (vfe == NULL) {
                (void)VFP_Error(vc, "Workspace overflow");
                return (NULL);
        }

        INIT_OBJ(vfe, VFP_ENTRY_MAGIC);
        vfe->vfp = vfp;
        vfe->closed = VFP_OK;
        VTAILQ_INSERT_HEAD(&vc->vfp, vfe, list);
        vc->vfp_nxt = vfe;
        return (vfe);
}

/*--------------------------------------------------------------------
 * Debugging aids
 */

static void v_matchproto_(cli_func_t)
debug_fragfetch(struct cli *cli, const char * const *av, void *priv)
{
        (void)priv;
        (void)cli;
        fetchfrag = strtoul(av[2], NULL, 0);
}

static struct cli_proto debug_cmds[] = {
        { CLICMD_DEBUG_FRAGFETCH,               "d", debug_fragfetch },
        { NULL }
};

/*--------------------------------------------------------------------
 *
 */

void
VFP_Init(void)
{

        CLI_AddFuncs(debug_cmds);
}

		varnish-cache/bin/varnishd/cache/cache_fetch_proc.c
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_varnishd.h"
36		#include "cache_filter.h"
37		#include "vcli_serve.h"
38
39		static unsigned fetchfrag;
40
41		/*--------------------------------------------------------------------
42		* We want to issue the first error we encounter on fetching and
43		* suppress the rest. This function does that.
44		*
45		* Other code is allowed to look at busyobj->fetch_failed to bail out
46		*
47		* For convenience, always return VFP_ERROR
48		*/
49
50		enum vfp_status
51	6150	VFP_Error(struct vfp_ctx vc, const char fmt, ...)
52		{
53		va_list ap;
54
55	6150	CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
56	6150	if (!vc->failed) {
57	3775	va_start(ap, fmt);
58	3775	VSLbv(vc->wrk->vsl, SLT_FetchError, fmt, ap);
59	3775	va_end(ap);
60	3775	vc->failed = 1;
61	3775	}
62	6150	return (VFP_ERROR);
63		}
64
65		/*--------------------------------------------------------------------
66		* Fetch Storage to put object into.
67		*
68		*/
69
70		enum vfp_status
71	1436642	VFP_GetStorage(struct vfp_ctx vc, ssize_t sz, uint8_t **ptr)
72		{
73
74	1436642	CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
75	1436642	AN(sz);
76	1436642	assert(*sz >= 0);
77	1436642	AN(ptr);
78
79	1436642	if (fetchfrag > 0)
80	1975	*sz = fetchfrag;
81
82	1436642	if (!ObjGetSpace(vc->wrk, vc->oc, sz, ptr)) {
83	125	*sz = 0;
84	125	*ptr = NULL;
85	125	return (VFP_Error(vc, "Could not get storage"));
86		}
87	1436517	assert(*sz > 0);
88	1436517	AN(*ptr);
89	1436517	return (VFP_OK);
90	1436642	}
91
92		void
93	1416924	VFP_Extend(const struct vfp_ctx *vc, ssize_t sz, enum vfp_status flg)
94		{
95	1416924	CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
96
97	1416924	ObjExtend(vc->wrk, vc->oc, sz, flg == VFP_END ? 1 : 0);
98	1416924	}
99
100		/**********************************************************************
101		*/
102
103		void
104	56649	VFP_Setup(struct vfp_ctx vc, struct worker wrk)
105		{
106
107	56649	INIT_OBJ(vc, VFP_CTX_MAGIC);
108	56649	VTAILQ_INIT(&vc->vfp);
109	56649	vc->wrk = wrk;
110	56649	}
111
112		/**********************************************************************
113		* Returns the number of bytes processed by the lowest VFP in the stack
114		*/
115
116		uint64_t
117	51824	VFP_Close(struct vfp_ctx *vc)
118		{
119		struct vfp_entry vfe, tmp;
120	51824	uint64_t rv = 0;
121
122	94347	VTAILQ_FOREACH_SAFE(vfe, &vc->vfp, list, tmp) {
123	42523	if (vfe->vfp->fini != NULL)
124	11925	vfe->vfp->fini(vc, vfe);
125	42523	rv = vfe->bytes_out;
126	85046	VSLb(vc->wrk->vsl, SLT_VfpAcct, "%s %ju %ju", vfe->vfp->name,
127	42523	(uintmax_t)vfe->calls, (uintmax_t)rv);
128	42523	VTAILQ_REMOVE(&vc->vfp, vfe, list);
129	42523	}
130	51824	return (rv);
131		}
132
133		int
134	47900	VFP_Open(VRT_CTX, struct vfp_ctx *vc)
135		{
136		struct vfp_entry *vfe;
137
138	47900	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
139	47900	CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
140	47900	CHECK_OBJ_NOTNULL(vc->resp, HTTP_MAGIC);
141	47900	CHECK_OBJ_NOTNULL(vc->wrk, WORKER_MAGIC);
142	47900	AN(vc->wrk->vsl);
143
144	87950	VTAILQ_FOREACH_REVERSE(vfe, &vc->vfp, vfp_entry_s, list) {
145	41375	if (vfe->vfp->init == NULL)
146	30325	continue;
147	11050	if (DO_DEBUG(DBG_PROCESSORS))
148	0	VSLb(vc->wrk->vsl, SLT_Debug, "VFP_Open(%s)",
149	0	vfe->vfp->name);
150	11050	vfe->closed = vfe->vfp->init(ctx, vc, vfe);
151	11050	if (vfe->closed != VFP_OK && vfe->closed != VFP_NULL) {
152	2650	(void)VFP_Error(vc, "Fetch filter %s failed to open",
153	1325	vfe->vfp->name);
154	1325	(void)VFP_Close(vc);
155	1325	return (-1);
156		}
157	9725	}
158
159	46575	return (0);
160	47900	}
161
162		/**********************************************************************
163		* Suck data up from lower levels.
164		* Once a layer return non VFP_OK, clean it up and produce the same
165		* return value for any subsequent calls.
166		*/
167
168		enum vfp_status
169	2756311	VFP_Suck(struct vfp_ctx vc, void p, ssize_t *lp)
170		{
171		enum vfp_status vp;
172		struct vfp_entry *vfe;
173
174	2756311	CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
175	2756311	AN(p);
176	2756311	AN(lp);
177	2756311	vfe = vc->vfp_nxt;
178	2756311	CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
179	2756311	vc->vfp_nxt = VTAILQ_NEXT(vfe, list);
180
181	2756311	if (vfe->closed == VFP_NULL) {
182		/* Layer asked to be bypassed when opened */
183	100	vp = VFP_Suck(vc, p, lp);
184	2756311	} else if (vfe->closed == VFP_OK) {
185	2754361	vp = vfe->vfp->pull(vc, vfe, p, lp);
186	2754361	if (vp != VFP_OK && vp != VFP_END && vp != VFP_ERROR)
187	0	vp = VFP_Error(vc, "Fetch filter %s returned %d",
188	0	vfe->vfp->name, vp);
189		else
190	2754361	vfe->bytes_out += *lp;
191	2754361	vfe->closed = vp;
192	2754361	vfe->calls++;
193	2754361	} else {
194		/* Already closed filter */
195	1850	*lp = 0;
196	1850	vp = vfe->closed;
197		}
198	2756311	vc->vfp_nxt = vfe;
199	2756311	assert(vp != VFP_NULL);
200	2756311	return (vp);
201		}
202
203		/*--------------------------------------------------------------------
204		*/
205
206		struct vfp_entry *
207	44073	VFP_Push(struct vfp_ctx vc, const struct vfp vfp)
208		{
209		struct vfp_entry *vfe;
210
211	44073	CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
212	44073	CHECK_OBJ_NOTNULL(vc->resp, HTTP_MAGIC);
213
214	44073	vfe = WS_Alloc(vc->resp->ws, sizeof *vfe);
215	44073	if (vfe == NULL) {
216	950	(void)VFP_Error(vc, "Workspace overflow");
217	950	return (NULL);
218		}
219
220	43123	INIT_OBJ(vfe, VFP_ENTRY_MAGIC);
221	43123	vfe->vfp = vfp;
222	43123	vfe->closed = VFP_OK;
223	43123	VTAILQ_INSERT_HEAD(&vc->vfp, vfe, list);
224	43123	vc->vfp_nxt = vfe;
225	43123	return (vfe);
226	44073	}
227
228		/*--------------------------------------------------------------------
229		* Debugging aids
230		*/
231
232		static void v_matchproto_(cli_func_t)
233	150	debug_fragfetch(struct cli cli, const char const av, void priv)
234		{
235	150	(void)priv;
236	150	(void)cli;
237	150	fetchfrag = strtoul(av[2], NULL, 0);
238	150	}
239
240		static struct cli_proto debug_cmds[] = {
241		{ CLICMD_DEBUG_FRAGFETCH, "d", debug_fragfetch },
242		{ NULL }
243		};
244
245		/*--------------------------------------------------------------------
246		*
247		*/
248
249		void
250	22197	VFP_Init(void)
251		{
252
253	22197	CLI_AddFuncs(debug_cmds);
254	22197	}