Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/systat/cache.c	Lines:	0	77	0.0 %
Date:	2016-12-06	Branches:	0	306	0.0 %


/* $Id: cache.c,v 1.6 2016/01/16 03:30:26 canacar 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 <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.6 2016/01/16 03:30:26 canacar 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
36			#include <assert.h>
37
38			#include "cache.h"
39
40			/* prototypes */
41			void update_state(struct sc_ent , struct pfsync_state , double);
42			struct sc_ent cache_state(struct pfsync_state );
43			static __inline int sc_cmp(struct sc_ent s1, struct sc_ent s2);
44
45			/* initialize the tree and queue */
46			RB_HEAD(sc_tree, sc_ent) sctree;
47			TAILQ_HEAD(sc_queue, sc_ent) scq1, scq2, scq_free;
48			RB_GENERATE(sc_tree, sc_ent, tlink, sc_cmp)
49
50			struct sc_queue *scq_act = NULL;
51			struct sc_queue *scq_exp = NULL;
52
53			int cache_max = 0;
54			int cache_size = 0;
55
56			struct sc_ent *sc_store = NULL;
57
58			/* preallocate the cache and insert into the 'free' queue */
59			int
60			cache_init(int max)
61			{
62			int n;
63			static int initialized = 0;
64
65			if (max < 0 \|\| initialized)
66			return (1);
67
68			if (max == 0) {
69			sc_store = NULL;
70			} else {
71			sc_store = reallocarray(NULL, max, sizeof(struct sc_ent));
72			if (sc_store == NULL)
73			return (1);
74			}
75
76			RB_INIT(&sctree);
77			TAILQ_INIT(&scq1);
78			TAILQ_INIT(&scq2);
79			TAILQ_INIT(&scq_free);
80
81			scq_act = &scq1;
82			scq_exp = &scq2;
83
84			for (n = 0; n < max; n++)
85			TAILQ_INSERT_HEAD(&scq_free, sc_store + n, qlink);
86
87			cache_size = cache_max = max;
88			initialized++;
89
90			return (0);
91			}
92
93			void
94			update_state(struct sc_ent prev, struct pfsync_state new, double rate)
95			{
96			assert (prev != NULL && new != NULL);
97			prev->t = time(NULL);
98			prev->rate = rate;
99			prev->bytes = COUNTER(new->bytes[0]) + COUNTER(new->bytes[1]);
100			if (prev->peak < rate)
101			prev->peak = rate;
102			}
103
104			void
105			add_state(struct pfsync_state *st)
106			{
107			struct sc_ent *ent;
108			assert(st != NULL);
109
110			if (cache_max == 0)
111			return;
112
113			if (TAILQ_EMPTY(&scq_free))
114			return;
115
116			ent = TAILQ_FIRST(&scq_free);
117			TAILQ_REMOVE(&scq_free, ent, qlink);
118
119			cache_size--;
120
121			ent->id = st->id;
122			ent->creatorid = st->creatorid;
123			ent->bytes = COUNTER(st->bytes[0]) + COUNTER(st->bytes[1]);
124			ent->peak = 0;
125			ent->rate = 0;
126			ent->t = 0;
127
128			RB_INSERT(sc_tree, &sctree, ent);
129			TAILQ_INSERT_HEAD(scq_act, ent, qlink);
130			}
131
132			/* must be called only once for each state before cache_endupdate */
133			struct sc_ent *
134			cache_state(struct pfsync_state *st)
135			{
136			struct sc_ent ent, *old;
137			double sd, td, r;
138
139			if (cache_max == 0)
140			return (NULL);
141
142			ent.id = st->id;
143			ent.creatorid = st->creatorid;
144			old = RB_FIND(sc_tree, &sctree, &ent);
145
146			if (old == NULL) {
147			add_state(st);
148			return (NULL);
149			}
150
151			if (COUNTER(st->bytes[0]) + COUNTER(st->bytes[1]) < old->bytes)
152			return (NULL);
153
154			sd = COUNTER(st->bytes[0]) + COUNTER(st->bytes[1]) - old->bytes;
155			td = time(NULL) - old->t;
156
157			if (td > 0) {
158			r = sd/td;
159			update_state(old, st, r);
160			}
161
162			/* move to active queue */
163			TAILQ_REMOVE(scq_exp, old, qlink);
164			TAILQ_INSERT_HEAD(scq_act, old, qlink);
165
166			return (old);
167			}
168
169			/* remove the states that are not updated in this cycle */
170			void
171			cache_endupdate(void)
172			{
173			struct sc_queue *tmp;
174			struct sc_ent *ent;
175
176			while (! TAILQ_EMPTY(scq_exp)) {
177			ent = TAILQ_FIRST(scq_exp);
178			TAILQ_REMOVE(scq_exp, ent, qlink);
179			RB_REMOVE(sc_tree, &sctree, ent);
180			TAILQ_INSERT_HEAD(&scq_free, ent, qlink);
181			cache_size++;
182			}
183
184			tmp = scq_act;
185			scq_act = scq_exp;
186			scq_exp = tmp;
187			}
188
189			static __inline int
190			sc_cmp(struct sc_ent a, struct sc_ent b)
191			{
192			if (a->id > b->id)
193			return (1);
194			if (a->id < b->id)
195			return (-1);
196			if (a->creatorid > b->creatorid)
197			return (1);
198			if (a->creatorid < b->creatorid)
199			return (-1);
200			return (0);
201			}