2 * ip_vs_est.c: simple rate estimator for IPVS
4 * Authors: Wensong Zhang <wensong@linuxvirtualserver.org>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
14 #include <linux/kernel.h>
15 #include <linux/jiffies.h>
16 #include <linux/slab.h>
17 #include <linux/types.h>
18 #include <linux/interrupt.h>
19 #include <linux/sysctl.h>
21 #include <net/ip_vs.h>
24 This code is to estimate rate in a shorter interval (such as 8
25 seconds) for virtual services and real servers. For measure rate in a
26 long interval, it is easy to implement a user level daemon which
27 periodically reads those statistical counters and measure rate.
29 Currently, the measurement is activated by slow timer handler. Hope
30 this measurement will not introduce too much load.
32 We measure rate during the last 8 seconds every 2 seconds:
34 avgrate = avgrate*(1-W) + rate*W
40 * The stored value for average bps is scaled by 2^5, so that maximal
41 rate is ~2.15Gbits/s, average pps and cps are scaled by 2^10.
43 * A lot code is taken from net/sched/estimator.c
47 struct ip_vs_estimator
49 struct ip_vs_estimator *next;
50 struct ip_vs_stats *stats;
66 static struct ip_vs_estimator *est_list = NULL;
67 static DEFINE_RWLOCK(est_lock);
68 static struct timer_list est_timer;
70 static void estimation_timer(unsigned long arg)
72 struct ip_vs_estimator *e;
73 struct ip_vs_stats *s;
75 u32 n_inpkts, n_outpkts;
76 u64 n_inbytes, n_outbytes;
80 for (e = est_list; e; e = e->next) {
86 n_outpkts = s->outpkts;
87 n_inbytes = s->inbytes;
88 n_outbytes = s->outbytes;
90 /* scaled by 2^10, but divided 2 seconds */
91 rate = (n_conns - e->last_conns)<<9;
92 e->last_conns = n_conns;
93 e->cps += ((long)rate - (long)e->cps)>>2;
94 s->cps = (e->cps+0x1FF)>>10;
96 rate = (n_inpkts - e->last_inpkts)<<9;
97 e->last_inpkts = n_inpkts;
98 e->inpps += ((long)rate - (long)e->inpps)>>2;
99 s->inpps = (e->inpps+0x1FF)>>10;
101 rate = (n_outpkts - e->last_outpkts)<<9;
102 e->last_outpkts = n_outpkts;
103 e->outpps += ((long)rate - (long)e->outpps)>>2;
104 s->outpps = (e->outpps+0x1FF)>>10;
106 rate = (n_inbytes - e->last_inbytes)<<4;
107 e->last_inbytes = n_inbytes;
108 e->inbps += ((long)rate - (long)e->inbps)>>2;
109 s->inbps = (e->inbps+0xF)>>5;
111 rate = (n_outbytes - e->last_outbytes)<<4;
112 e->last_outbytes = n_outbytes;
113 e->outbps += ((long)rate - (long)e->outbps)>>2;
114 s->outbps = (e->outbps+0xF)>>5;
115 spin_unlock(&s->lock);
117 read_unlock(&est_lock);
118 mod_timer(&est_timer, jiffies + 2*HZ);
121 int ip_vs_new_estimator(struct ip_vs_stats *stats)
123 struct ip_vs_estimator *est;
125 est = kzalloc(sizeof(*est), GFP_KERNEL);
130 est->last_conns = stats->conns;
131 est->cps = stats->cps<<10;
133 est->last_inpkts = stats->inpkts;
134 est->inpps = stats->inpps<<10;
136 est->last_outpkts = stats->outpkts;
137 est->outpps = stats->outpps<<10;
139 est->last_inbytes = stats->inbytes;
140 est->inbps = stats->inbps<<5;
142 est->last_outbytes = stats->outbytes;
143 est->outbps = stats->outbps<<5;
145 write_lock_bh(&est_lock);
146 est->next = est_list;
147 if (est->next == NULL) {
148 setup_timer(&est_timer, estimation_timer, 0);
149 est_timer.expires = jiffies + 2*HZ;
150 add_timer(&est_timer);
153 write_unlock_bh(&est_lock);
157 void ip_vs_kill_estimator(struct ip_vs_stats *stats)
159 struct ip_vs_estimator *est, **pest;
162 write_lock_bh(&est_lock);
164 while ((est=*pest) != NULL) {
165 if (est->stats != stats) {
173 if (killed && est_list == NULL)
174 del_timer_sync(&est_timer);
175 write_unlock_bh(&est_lock);
178 void ip_vs_zero_estimator(struct ip_vs_stats *stats)
180 struct ip_vs_estimator *e;
182 write_lock_bh(&est_lock);
183 for (e = est_list; e; e = e->next) {
184 if (e->stats != stats)
187 /* set counters zero */
192 e->last_outbytes = 0;
199 write_unlock_bh(&est_lock);