Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/systat/cache.c	Lines:	0	77	0.0 %
Date:	2017-11-07	Branches:	0	226	0.0 %


/* $Id: cache.c,v 1.7 2016/08/26 09:10:11 guenther Exp $ */
/*
 * Copyright (c) 2001, 2007 Can Erkin Acar <canacar@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/socket.h>

#include <net/if.h>
#include <netinet/in.h>

#include <netinet/tcp_fsm.h>
#ifdef TEST_COMPAT
#include "pfvarmux.h"
#else
#include <net/pfvar.h>
#endif
#include <arpa/inet.h>

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include <assert.h>

#include "cache.h"

/* prototypes */
void update_state(struct sc_ent *, struct pfsync_state *, double);
struct sc_ent *cache_state(struct pfsync_state *);
static __inline int sc_cmp(struct sc_ent *s1, struct sc_ent *s2);

/* initialize the tree and queue */
RB_HEAD(sc_tree, sc_ent) sctree;
TAILQ_HEAD(sc_queue, sc_ent) scq1, scq2, scq_free;
RB_GENERATE(sc_tree, sc_ent, tlink, sc_cmp)

struct sc_queue *scq_act = NULL;
struct sc_queue *scq_exp = NULL;

int cache_max = 0;
int cache_size = 0;

struct sc_ent *sc_store = NULL;

/* preallocate the cache and insert into the 'free' queue */
int
cache_init(int max)
{
	int n;
	static int initialized = 0;

	if (max < 0 || initialized)
		return (1);

	if (max == 0) {
		sc_store = NULL;
	} else {
		sc_store = reallocarray(NULL, max, sizeof(struct sc_ent));
		if (sc_store == NULL)
			return (1);
	}

	RB_INIT(&sctree);
	TAILQ_INIT(&scq1);
	TAILQ_INIT(&scq2);
	TAILQ_INIT(&scq_free);

	scq_act = &scq1;
	scq_exp = &scq2;

	for (n = 0; n < max; n++)
		TAILQ_INSERT_HEAD(&scq_free, sc_store + n, qlink);

	cache_size = cache_max = max;
	initialized++;

	return (0);
}

void
update_state(struct sc_ent *prev, struct pfsync_state *new, double rate)
{
	assert (prev != NULL && new != NULL);
	prev->t = time(NULL);
	prev->rate = rate;
	prev->bytes = COUNTER(new->bytes[0]) + COUNTER(new->bytes[1]);
	if (prev->peak < rate)
		prev->peak = rate;
}

void
add_state(struct pfsync_state *st)
{
	struct sc_ent *ent;
	assert(st != NULL);

	if (cache_max == 0)
		return;

	if (TAILQ_EMPTY(&scq_free))
		return;

	ent = TAILQ_FIRST(&scq_free);
	TAILQ_REMOVE(&scq_free, ent, qlink);

	cache_size--;

	ent->id = st->id;
	ent->creatorid = st->creatorid;
	ent->bytes = COUNTER(st->bytes[0]) + COUNTER(st->bytes[1]);
	ent->peak = 0;
	ent->rate = 0;
	ent->t = 0;

	RB_INSERT(sc_tree, &sctree, ent);
	TAILQ_INSERT_HEAD(scq_act, ent, qlink);
}

/* must be called only once for each state before cache_endupdate */
struct sc_ent *
cache_state(struct pfsync_state *st)
{
	struct sc_ent ent, *old;
	double sd, td, r;

	if (cache_max == 0)
		return (NULL);

	ent.id = st->id;
	ent.creatorid = st->creatorid;
	old = RB_FIND(sc_tree, &sctree, &ent);

	if (old == NULL) {
		add_state(st);
		return (NULL);
	}

	if (COUNTER(st->bytes[0]) + COUNTER(st->bytes[1]) < old->bytes)
		return (NULL);

	sd = COUNTER(st->bytes[0]) + COUNTER(st->bytes[1]) - old->bytes;
	td = time(NULL) - old->t;

	if (td > 0) {
		r = sd/td;
		update_state(old, st, r);
	}

	/* move to active queue */
	TAILQ_REMOVE(scq_exp, old, qlink);
	TAILQ_INSERT_HEAD(scq_act, old, qlink);

	return (old);
}

/* remove the states that are not updated in this cycle */
void
cache_endupdate(void)
{
	struct sc_queue *tmp;
	struct sc_ent *ent;

	while (! TAILQ_EMPTY(scq_exp)) {
		ent = TAILQ_FIRST(scq_exp);
		TAILQ_REMOVE(scq_exp, ent, qlink);
		RB_REMOVE(sc_tree, &sctree, ent);
		TAILQ_INSERT_HEAD(&scq_free, ent, qlink);
		cache_size++;
	}

	tmp = scq_act;
	scq_act = scq_exp;
	scq_exp = tmp;
}

static __inline int
sc_cmp(struct sc_ent *a, struct sc_ent *b)
{
	if (a->id > b->id)
		return (1);
	if (a->id < b->id)
		return (-1);
	if (a->creatorid > b->creatorid)
		return (1);
	if (a->creatorid < b->creatorid)
		return (-1);
	return (0);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $Id: cache.c,v 1.7 2016/08/26 09:10:11 guenther Exp $ */
2			/*
3			* Copyright (c) 2001, 2007 Can Erkin Acar <canacar@openbsd.org>
4			*
5			* Permission to use, copy, modify, and distribute this software for any
6			* purpose with or without fee is hereby granted, provided that the above
7			* copyright notice and this permission notice appear in all copies.
8			*
9			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16			*/
17
18			#include <sys/types.h>
19			#include <sys/ioctl.h>
20			#include <sys/socket.h>
21
22			#include <net/if.h>
23			#include <netinet/in.h>
24
25			#include <netinet/tcp_fsm.h>
26			#ifdef TEST_COMPAT
27			#include "pfvarmux.h"
28			#else
29			#include <net/pfvar.h>
30			#endif
31			#include <arpa/inet.h>
32
33			#include <stdio.h>
34			#include <stdlib.h>
35			#include <time.h>
36
37			#include <assert.h>
38
39			#include "cache.h"
40
41			/* prototypes */
42			void update_state(struct sc_ent , struct pfsync_state , double);
43			struct sc_ent cache_state(struct pfsync_state );
44			static __inline int sc_cmp(struct sc_ent s1, struct sc_ent s2);
45
46			/* initialize the tree and queue */
47			RB_HEAD(sc_tree, sc_ent) sctree;
48			TAILQ_HEAD(sc_queue, sc_ent) scq1, scq2, scq_free;
49			RB_GENERATE(sc_tree, sc_ent, tlink, sc_cmp)
50
51			struct sc_queue *scq_act = NULL;
52			struct sc_queue *scq_exp = NULL;
53
54			int cache_max = 0;
55			int cache_size = 0;
56
57			struct sc_ent *sc_store = NULL;
58
59			/* preallocate the cache and insert into the 'free' queue */
60			int
61			cache_init(int max)
62			{
63			int n;
64			static int initialized = 0;
65
66			if (max < 0 \|\| initialized)
67			return (1);
68
69			if (max == 0) {
70			sc_store = NULL;
71			} else {
72			sc_store = reallocarray(NULL, max, sizeof(struct sc_ent));
73			if (sc_store == NULL)
74			return (1);
75			}
76
77			RB_INIT(&sctree);
78			TAILQ_INIT(&scq1);
79			TAILQ_INIT(&scq2);
80			TAILQ_INIT(&scq_free);
81
82			scq_act = &scq1;
83			scq_exp = &scq2;
84
85			for (n = 0; n < max; n++)
86			TAILQ_INSERT_HEAD(&scq_free, sc_store + n, qlink);
87
88			cache_size = cache_max = max;
89			initialized++;
90
91			return (0);
92			}
93
94			void
95			update_state(struct sc_ent prev, struct pfsync_state new, double rate)
96			{
97			assert (prev != NULL && new != NULL);
98			prev->t = time(NULL);
99			prev->rate = rate;
100			prev->bytes = COUNTER(new->bytes[0]) + COUNTER(new->bytes[1]);
101			if (prev->peak < rate)
102			prev->peak = rate;
103			}
104
105			void
106			add_state(struct pfsync_state *st)
107			{
108			struct sc_ent *ent;
109			assert(st != NULL);
110
111			if (cache_max == 0)
112			return;
113
114			if (TAILQ_EMPTY(&scq_free))
115			return;
116
117			ent = TAILQ_FIRST(&scq_free);
118			TAILQ_REMOVE(&scq_free, ent, qlink);
119
120			cache_size--;
121
122			ent->id = st->id;
123			ent->creatorid = st->creatorid;
124			ent->bytes = COUNTER(st->bytes[0]) + COUNTER(st->bytes[1]);
125			ent->peak = 0;
126			ent->rate = 0;
127			ent->t = 0;
128
129			RB_INSERT(sc_tree, &sctree, ent);
130			TAILQ_INSERT_HEAD(scq_act, ent, qlink);
131			}
132
133			/* must be called only once for each state before cache_endupdate */
134			struct sc_ent *
135			cache_state(struct pfsync_state *st)
136			{
137			struct sc_ent ent, *old;
138			double sd, td, r;
139
140			if (cache_max == 0)
141			return (NULL);
142
143			ent.id = st->id;
144			ent.creatorid = st->creatorid;
145			old = RB_FIND(sc_tree, &sctree, &ent);
146
147			if (old == NULL) {
148			add_state(st);
149			return (NULL);
150			}
151
152			if (COUNTER(st->bytes[0]) + COUNTER(st->bytes[1]) < old->bytes)
153			return (NULL);
154
155			sd = COUNTER(st->bytes[0]) + COUNTER(st->bytes[1]) - old->bytes;
156			td = time(NULL) - old->t;
157
158			if (td > 0) {
159			r = sd/td;
160			update_state(old, st, r);
161			}
162
163			/* move to active queue */
164			TAILQ_REMOVE(scq_exp, old, qlink);
165			TAILQ_INSERT_HEAD(scq_act, old, qlink);
166
167			return (old);
168			}
169
170			/* remove the states that are not updated in this cycle */
171			void
172			cache_endupdate(void)
173			{
174			struct sc_queue *tmp;
175			struct sc_ent *ent;
176
177			while (! TAILQ_EMPTY(scq_exp)) {
178			ent = TAILQ_FIRST(scq_exp);
179			TAILQ_REMOVE(scq_exp, ent, qlink);
180			RB_REMOVE(sc_tree, &sctree, ent);
181			TAILQ_INSERT_HEAD(&scq_free, ent, qlink);
182			cache_size++;
183			}
184
185			tmp = scq_act;
186			scq_act = scq_exp;
187			scq_exp = tmp;
188			}
189
190			static __inline int
191			sc_cmp(struct sc_ent a, struct sc_ent b)
192			{
193			if (a->id > b->id)
194			return (1);
195			if (a->id < b->id)
196			return (-1);
197			if (a->creatorid > b->creatorid)
198			return (1);
199			if (a->creatorid < b->creatorid)
200			return (-1);
201			return (0);
202			}