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_int.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, *vfe_prev;
        const char *prev_name = "<storage>";
        ssize_t limit;

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

        vfe_prev = VTAILQ_PREV(vfe, vfp_entry_s, list);
        if (vfe_prev != NULL)
                prev_name = vfe_prev->vfp->name;

        if (vfe->closed == VFP_NULL) {
                /* Layer asked to be bypassed when opened */
                vp = VFP_Suck(vc, p, lp);
                VFP_DEBUG(vc, "bypassing %s vp=%d", vfe->vfp->name, vp);
        } else if (vfe->closed == VFP_OK) {
                vp = vfe->vfp->pull(vc, vfe, p, lp);
                VFP_DEBUG(vc, "%s pulled %zdB/%zdB from %s vp=%d",
                    prev_name, *lp, limit, vfe->vfp->name, vp);
                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;
                VFP_DEBUG(vc, "ignoring %s vp=%d", vfe->vfp->name, vp);
        }
        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);
}

		vinyl-cache/bin/vinyld/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_int.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	1052	VFP_Error(struct vfp_ctx vc, const char fmt, ...)
52		{
53		va_list ap;
54
55	1052	CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
56	1052	if (!vc->failed) {
57	652	va_start(ap, fmt);
58	652	VSLbv(vc->wrk->vsl, SLT_FetchError, fmt, ap);
59	652	va_end(ap);
60	652	vc->failed = 1;
61	652	}
62	1052	return (VFP_ERROR);
63		}
64
65		/*--------------------------------------------------------------------
66		* Fetch Storage to put object into.
67		*
68		*/
69
70		enum vfp_status
71	238418	VFP_GetStorage(struct vfp_ctx vc, ssize_t sz, uint8_t **ptr)
72		{
73
74	238418	CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
75	238418	AN(sz);
76	238418	assert(*sz >= 0);
77	238418	AN(ptr);
78
79	238418	if (fetchfrag > 0)
80	312	*sz = fetchfrag;
81
82	238418	if (!ObjGetSpace(vc->wrk, vc->oc, sz, ptr)) {
83	32	*sz = 0;
84	32	*ptr = NULL;
85	32	return (VFP_Error(vc, "Could not get storage"));
86		}
87	238386	assert(*sz > 0);
88	238386	AN(*ptr);
89	238386	return (VFP_OK);
90	238418	}
91
92		void
93	234973	VFP_Extend(const struct vfp_ctx *vc, ssize_t sz, enum vfp_status flg)
94		{
95	234973	CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
96
97	234973	ObjExtend(vc->wrk, vc->oc, sz, flg == VFP_END ? 1 : 0);
98	234973	}
99
100		/**********************************************************************
101		*/
102
103		void
104	10119	VFP_Setup(struct vfp_ctx vc, struct worker wrk)
105		{
106
107	10119	INIT_OBJ(vc, VFP_CTX_MAGIC);
108	10119	VTAILQ_INIT(&vc->vfp);
109	10119	vc->wrk = wrk;
110	10119	}
111
112		/**********************************************************************
113		* Returns the number of bytes processed by the lowest VFP in the stack
114		*/
115
116		uint64_t
117	9126	VFP_Close(struct vfp_ctx *vc)
118		{
119		struct vfp_entry vfe, tmp;
120	9126	uint64_t rv = 0;
121
122	16474	VTAILQ_FOREACH_SAFE(vfe, &vc->vfp, list, tmp) {
123	7348	if (vfe->vfp->fini != NULL)
124	1940	vfe->vfp->fini(vc, vfe);
125	7348	rv = vfe->bytes_out;
126	14696	VSLb(vc->wrk->vsl, SLT_VfpAcct, "%s %ju %ju", vfe->vfp->name,
127	7348	(uintmax_t)vfe->calls, (uintmax_t)rv);
128	7348	VTAILQ_REMOVE(&vc->vfp, vfe, list);
129	7348	}
130	9126	return (rv);
131		}
132
133		int
134	8440	VFP_Open(VRT_CTX, struct vfp_ctx *vc)
135		{
136		struct vfp_entry *vfe;
137
138	8440	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
139	8440	CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
140	8440	CHECK_OBJ_NOTNULL(vc->resp, HTTP_MAGIC);
141	8440	CHECK_OBJ_NOTNULL(vc->wrk, WORKER_MAGIC);
142	8440	AN(vc->wrk->vsl);
143
144	15384	VTAILQ_FOREACH_REVERSE(vfe, &vc->vfp, vfp_entry_s, list) {
145	7156	if (vfe->vfp->init == NULL)
146	5364	continue;
147	1792	if (DO_DEBUG(DBG_PROCESSORS))
148	8	VSLb(vc->wrk->vsl, SLT_Debug, "VFP_Open(%s)",
149	4	vfe->vfp->name);
150	1792	vfe->closed = vfe->vfp->init(ctx, vc, vfe);
151	1792	if (vfe->closed != VFP_OK && vfe->closed != VFP_NULL) {
152	424	(void)VFP_Error(vc, "Fetch filter %s failed to open",
153	212	vfe->vfp->name);
154	212	(void)VFP_Close(vc);
155	212	return (-1);
156		}
157	1580	}
158
159	8228	return (0);
160	8440	}
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	449381	VFP_Suck(struct vfp_ctx vc, void p, ssize_t *lp)
170		{
171		enum vfp_status vp;
172		struct vfp_entry vfe, vfe_prev;
173	449381	const char *prev_name = "<storage>";
174		ssize_t limit;
175
176	449381	CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
177	449381	AN(p);
178	449381	AN(lp);
179	449381	limit = *lp;
180	449381	vfe = vc->vfp_nxt;
181	449381	CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
182	449381	vc->vfp_nxt = VTAILQ_NEXT(vfe, list);
183
184	449381	vfe_prev = VTAILQ_PREV(vfe, vfp_entry_s, list);
185	449381	if (vfe_prev != NULL)
186	216684	prev_name = vfe_prev->vfp->name;
187
188	449381	if (vfe->closed == VFP_NULL) {
189		/* Layer asked to be bypassed when opened */
190	16	vp = VFP_Suck(vc, p, lp);
191	16	VFP_DEBUG(vc, "bypassing %s vp=%d", vfe->vfp->name, vp);
192	449381	} else if (vfe->closed == VFP_OK) {
193	449065	vp = vfe->vfp->pull(vc, vfe, p, lp);
194	449065	VFP_DEBUG(vc, "%s pulled %zdB/%zdB from %s vp=%d",
195		prev_name, *lp, limit, vfe->vfp->name, vp);
196	449065	if (vp != VFP_OK && vp != VFP_END && vp != VFP_ERROR)
197	0	vp = VFP_Error(vc, "Fetch filter %s returned %d",
198	0	vfe->vfp->name, vp);
199		else
200	449065	vfe->bytes_out += *lp;
201	449065	vfe->closed = vp;
202	449065	vfe->calls++;
203	449065	} else {
204		/* Already closed filter */
205	300	*lp = 0;
206	300	vp = vfe->closed;
207	300	VFP_DEBUG(vc, "ignoring %s vp=%d", vfe->vfp->name, vp);
208		}
209	449381	vc->vfp_nxt = vfe;
210	449381	assert(vp != VFP_NULL);
211	449381	return (vp);
212		}
213
214		/*--------------------------------------------------------------------
215		*/
216
217		struct vfp_entry *
218	7608	VFP_Push(struct vfp_ctx vc, const struct vfp vfp)
219		{
220		struct vfp_entry *vfe;
221
222	7608	CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
223	7608	CHECK_OBJ_NOTNULL(vc->resp, HTTP_MAGIC);
224
225	7608	vfe = WS_Alloc(vc->resp->ws, sizeof *vfe);
226	7608	if (vfe == NULL) {
227	152	(void)VFP_Error(vc, "Workspace overflow");
228	152	return (NULL);
229		}
230
231	7456	INIT_OBJ(vfe, VFP_ENTRY_MAGIC);
232	7456	vfe->vfp = vfp;
233	7456	vfe->closed = VFP_OK;
234	7456	VTAILQ_INSERT_HEAD(&vc->vfp, vfe, list);
235	7456	vc->vfp_nxt = vfe;
236	7456	return (vfe);
237	7608	}
238
239		/*--------------------------------------------------------------------
240		* Debugging aids
241		*/
242
243		static void v_matchproto_(cli_func_t)
244	28	debug_fragfetch(struct cli cli, const char const av, void priv)
245		{
246	28	(void)priv;
247	28	(void)cli;
248	28	fetchfrag = strtoul(av[2], NULL, 0);
249	28	}
250
251		static struct cli_proto debug_cmds[] = {
252		{ CLICMD_DEBUG_FRAGFETCH, "d", debug_fragfetch },
253		{ NULL }
254		};
255
256		/*--------------------------------------------------------------------
257		*
258		*/
259
260		void
261	3892	VFP_Init(void)
262		{
263
264	3892	CLI_AddFuncs(debug_cmds);
265	3892	}