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 <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "vdef.h"
#include "vrt.h"

#include "miniobj.h"
#include "vas.h"
#include "vmb.h"
#include "vsc_priv.h"
#include "vqueue.h"

#include "heritage.h"
#include "vsmw.h"

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

struct vsc_seg {
        unsigned                magic;
#define VSC_SEG_MAGIC           0x9b355991

        struct vsmw             *vsm;           // keep master/child sep.
        const char              *nm;
        VTAILQ_ENTRY(vsc_seg)   list;
        void                    *seg;

        /* VSC segments */
        struct vsc_head         *head;
        void                    *ptr;
        struct vsc_seg          *doc;

        /* DOC segments */
        const unsigned char     *jp;
        int                     refs;
};

static VTAILQ_HEAD(,vsc_seg)    vsc_seglist =
    VTAILQ_HEAD_INITIALIZER(vsc_seglist);

static void v_matchproto_(vsm_lock_f)
vsc_dummy_lock(void)
{
}

vsm_lock_f *vsc_lock = vsc_dummy_lock;
vsm_lock_f *vsc_unlock = vsc_dummy_lock;

static const size_t vsc_overhead = PRNDUP(sizeof(struct vsc_head));

static struct vsc_seg *
vrt_vsc_mksegv(struct vsmw_cluster *vc, const char *category,
    size_t payload, const char *prefix, const char *fmt, va_list va)
{
        struct vsc_seg *vsg;

        ALLOC_OBJ(vsg, VSC_SEG_MAGIC);
        AN(vsg);
        vsg->seg = VSMW_Allocv(heritage.proc_vsmw, vc, category,
            VRT_VSC_Overhead(payload), prefix, fmt, va);
        AN(vsg->seg);
        vsg->vsm = heritage.proc_vsmw;
        vsg->head = (void*)vsg->seg;
        vsg->head->body_offset = vsc_overhead;
        vsg->ptr = (char*)vsg->seg + vsc_overhead;
        return (vsg);
}

static struct vsc_seg *
vrt_vsc_mksegf(const char *category, size_t payload, const char *fmt, ...)
{
        va_list ap;
        struct vsc_seg *vsg;

        va_start(ap, fmt);
        vsg = vrt_vsc_mksegv(NULL, category, payload, NULL, fmt, ap);
        va_end(ap);
        return (vsg);
}

size_t
VRT_VSC_Overhead(size_t payload)
{
        return (vsc_overhead + PRNDUP(payload));
}

void
VRT_VSC_Hide(const struct vsc_seg *vsg)
{
        CHECK_OBJ_NOTNULL(vsg, VSC_SEG_MAGIC);
        assert(vsg->head->ready > 0);
        vsg->head->ready = 2;
}

void
VRT_VSC_Reveal(const struct vsc_seg *vsg)
{
        CHECK_OBJ_NOTNULL(vsg, VSC_SEG_MAGIC);
        assert(vsg->head->ready > 0);
        vsg->head->ready = 1;
}

void *
VRT_VSC_Allocv(struct vsmw_cluster *vc, struct vsc_seg **sg,
    const char *nm, size_t sd,
    const unsigned char *jp, size_t sj, const char *fmt, va_list va)
{
        struct vsc_seg *vsg, *dvsg;
        uintptr_t jjp;

        vsc_lock();

        jjp = (uintptr_t)jp;

        VTAILQ_FOREACH(dvsg, &vsc_seglist, list) {
                if (dvsg->vsm != heritage.proc_vsmw)
                        continue;
                if (dvsg->jp == NULL || dvsg->jp == jp)
                        break;
        }
        if (dvsg == NULL || dvsg->jp == NULL) {
                /* Create a new documentation segment */
                dvsg = vrt_vsc_mksegf(VSC_DOC_CLASS, sj,
                    "%jx", (uintmax_t)jjp);
                AN(dvsg);
                dvsg->jp = jp;
                dvsg->head->doc_id = jjp;
                memcpy(dvsg->ptr, jp, sj);
                VWMB();
                dvsg->head->ready = 1;
                VTAILQ_INSERT_HEAD(&vsc_seglist, dvsg, list);
        }
        AN(dvsg);
        dvsg->refs++;

        AN(heritage.proc_vsmw);

        vsg = vrt_vsc_mksegv(vc, VSC_CLASS, sd, nm, fmt, va);
        AN(vsg);
        vsg->nm = nm;
        vsg->doc = dvsg;
        vsg->head->doc_id = jjp;
        VTAILQ_INSERT_TAIL(&vsc_seglist, vsg, list);
        VWMB();
        vsg->head->ready = 1;
        vsc_unlock();
        if (sg != NULL)
                *sg = vsg;
        return (vsg->ptr);
}

void *
VRT_VSC_Alloc(struct vsmw_cluster *vc, struct vsc_seg **sg,
    const char *nm, size_t sd,
    const unsigned char *jp, size_t sj, const char *fmt, ...)
{
        va_list ap;
        void *retval;

        va_start(ap, fmt);
        retval = VRT_VSC_Allocv(vc, sg, nm, sd, jp, sj, fmt, ap);
        va_end(ap);
        return(retval);
}

void
VRT_VSC_Destroy(const char *nm, struct vsc_seg *vsg)
{
        struct vsc_seg *dvsg;

        vsc_lock();

        AN(heritage.proc_vsmw);
        CHECK_OBJ_NOTNULL(vsg, VSC_SEG_MAGIC);
        CAST_OBJ_NOTNULL(dvsg, vsg->doc, VSC_SEG_MAGIC);
        AZ(vsg->jp);
        assert(vsg->vsm == heritage.proc_vsmw);
        assert(vsg->nm == nm);

        VSMW_Free(heritage.proc_vsmw, &vsg->seg);
        VTAILQ_REMOVE(&vsc_seglist, vsg, list);
        FREE_OBJ(vsg);
        if (--dvsg->refs == 0) {
                VSMW_Free(heritage.proc_vsmw, &dvsg->seg);
                VTAILQ_REMOVE(&vsc_seglist, dvsg, list);
                FREE_OBJ(dvsg);
        }
        vsc_unlock();
}

		varnish-cache/bin/varnishd/common/common_vsc.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 <stdarg.h>
34		#include <stdio.h>
35		#include <string.h>
36		#include <stdlib.h>
37
38		#include "vdef.h"
39		#include "vrt.h"
40
41		#include "miniobj.h"
42		#include "vas.h"
43		#include "vmb.h"
44		#include "vsc_priv.h"
45		#include "vqueue.h"
46
47		#include "heritage.h"
48		#include "vsmw.h"
49
50		/--------------------------------------------------------------------/
51
52		struct vsc_seg {
53		unsigned magic;
54		#define VSC_SEG_MAGIC 0x9b355991
55
56		struct vsmw *vsm; // keep master/child sep.
57		const char *nm;
58		VTAILQ_ENTRY(vsc_seg) list;
59		void *seg;
60
61		/* VSC segments */
62		struct vsc_head *head;
63		void *ptr;
64		struct vsc_seg *doc;
65
66		/* DOC segments */
67		const unsigned char *jp;
68		int refs;
69		};
70
71		static VTAILQ_HEAD(,vsc_seg) vsc_seglist =
72		VTAILQ_HEAD_INITIALIZER(vsc_seglist);
73
74		static void v_matchproto_(vsm_lock_f)
75	78152	vsc_dummy_lock(void)
76		{
77	78152	}
78
79		vsm_lock_f *vsc_lock = vsc_dummy_lock;
80		vsm_lock_f *vsc_unlock = vsc_dummy_lock;
81
82		static const size_t vsc_overhead = PRNDUP(sizeof(struct vsc_head));
83
84		static struct vsc_seg *
85	1723355	vrt_vsc_mksegv(struct vsmw_cluster vc, const char category,
86		size_t payload, const char prefix, const char fmt, va_list va)
87		{
88		struct vsc_seg *vsg;
89
90	1723355	ALLOC_OBJ(vsg, VSC_SEG_MAGIC);
91	1723355	AN(vsg);
92	3446710	vsg->seg = VSMW_Allocv(heritage.proc_vsmw, vc, category,
93	1723355	VRT_VSC_Overhead(payload), prefix, fmt, va);
94	1723355	AN(vsg->seg);
95	1723355	vsg->vsm = heritage.proc_vsmw;
96	1723355	vsg->head = (void*)vsg->seg;
97	1723355	vsg->head->body_offset = vsc_overhead;
98	1723355	vsg->ptr = (char*)vsg->seg + vsc_overhead;
99	1723355	return (vsg);
100		}
101
102		static struct vsc_seg *
103	302194	vrt_vsc_mksegf(const char category, size_t payload, const char fmt, ...)
104		{
105		va_list ap;
106		struct vsc_seg *vsg;
107
108	302194	va_start(ap, fmt);
109	302194	vsg = vrt_vsc_mksegv(NULL, category, payload, NULL, fmt, ap);
110	302194	va_end(ap);
111	302194	return (vsg);
112		}
113
114		size_t
115	1772755	VRT_VSC_Overhead(size_t payload)
116		{
117	1772755	return (vsc_overhead + PRNDUP(payload));
118		}
119
120		void
121	56387	VRT_VSC_Hide(const struct vsc_seg *vsg)
122		{
123	56387	CHECK_OBJ_NOTNULL(vsg, VSC_SEG_MAGIC);
124	56387	assert(vsg->head->ready > 0);
125	56387	vsg->head->ready = 2;
126	56387	}
127
128		void
129	53400	VRT_VSC_Reveal(const struct vsc_seg *vsg)
130		{
131	53400	CHECK_OBJ_NOTNULL(vsg, VSC_SEG_MAGIC);
132	53400	assert(vsg->head->ready > 0);
133	53400	vsg->head->ready = 1;
134	53400	}
135
136		void *
137	1421161	VRT_VSC_Allocv(struct vsmw_cluster vc, struct vsc_seg *sg,
138		const char *nm, size_t sd,
139		const unsigned char jp, size_t sj, const char fmt, va_list va)
140		{
141		struct vsc_seg vsg, dvsg;
142		uintptr_t jjp;
143
144	1421161	vsc_lock();
145
146	1421161	jjp = (uintptr_t)jp;
147
148	3260273	VTAILQ_FOREACH(dvsg, &vsc_seglist, list) {
149	3183168	if (dvsg->vsm != heritage.proc_vsmw)
150	526236	continue;
151	2656932	if (dvsg->jp == NULL \|\| dvsg->jp == jp)
152	1344056	break;
153	1312876	}
154	1421161	if (dvsg == NULL \|\| dvsg->jp == NULL) {
155		/* Create a new documentation segment */
156	604388	dvsg = vrt_vsc_mksegf(VSC_DOC_CLASS, sj,
157	302194	"%jx", (uintmax_t)jjp);
158	302194	AN(dvsg);
159	302194	dvsg->jp = jp;
160	302194	dvsg->head->doc_id = jjp;
161	302194	memcpy(dvsg->ptr, jp, sj);
162	302194	VWMB();
163	302194	dvsg->head->ready = 1;
164	302194	VTAILQ_INSERT_HEAD(&vsc_seglist, dvsg, list);
165	302194	}
166	1421161	AN(dvsg);
167	1421161	dvsg->refs++;
168
169	1421161	AN(heritage.proc_vsmw);
170
171	1421161	vsg = vrt_vsc_mksegv(vc, VSC_CLASS, sd, nm, fmt, va);
172	1421161	AN(vsg);
173	1421161	vsg->nm = nm;
174	1421161	vsg->doc = dvsg;
175	1421161	vsg->head->doc_id = jjp;
176	1421161	VTAILQ_INSERT_TAIL(&vsc_seglist, vsg, list);
177	1421161	VWMB();
178	1421161	vsg->head->ready = 1;
179	1421161	vsc_unlock();
180	1421161	if (sg != NULL)
181	242058	*sg = vsg;
182	1421161	return (vsg->ptr);
183		}
184
185		void *
186	0	VRT_VSC_Alloc(struct vsmw_cluster vc, struct vsc_seg *sg,
187		const char *nm, size_t sd,
188		const unsigned char jp, size_t sj, const char fmt, ...)
189		{
190		va_list ap;
191		void *retval;
192
193	0	va_start(ap, fmt);
194	0	retval = VRT_VSC_Allocv(vc, sg, nm, sd, jp, sj, fmt, ap);
195	0	va_end(ap);
196	0	return(retval);
197		}
198
199		void
200	3429	VRT_VSC_Destroy(const char nm, struct vsc_seg vsg)
201		{
202		struct vsc_seg *dvsg;
203
204	3429	vsc_lock();
205
206	3429	AN(heritage.proc_vsmw);
207	3429	CHECK_OBJ_NOTNULL(vsg, VSC_SEG_MAGIC);
208	3429	CAST_OBJ_NOTNULL(dvsg, vsg->doc, VSC_SEG_MAGIC);
209	3429	AZ(vsg->jp);
210	3429	assert(vsg->vsm == heritage.proc_vsmw);
211	3429	assert(vsg->nm == nm);
212
213	3429	VSMW_Free(heritage.proc_vsmw, &vsg->seg);
214	3429	VTAILQ_REMOVE(&vsc_seglist, vsg, list);
215	3429	FREE_OBJ(vsg);
216	3429	if (--dvsg->refs == 0) {
217	80	VSMW_Free(heritage.proc_vsmw, &dvsg->seg);
218	80	VTAILQ_REMOVE(&vsc_seglist, dvsg, list);
219	80	FREE_OBJ(dvsg);
220	80	}
221	3429	vsc_unlock();
222	3429	}