88bd71647bf521fdd35b0288be8845fd554b7691
[linux-2.6.git] / net / netfilter / ipvs / ip_vs_est.c
1 /*
2  * ip_vs_est.c: simple rate estimator for IPVS
3  *
4  * Authors:     Wensong Zhang <wensong@linuxvirtualserver.org>
5  *
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.
10  *
11  * Changes:     Hans Schillstrom <hans.schillstrom@ericsson.com>
12  *              Network name space (netns) aware.
13  *              Global data moved to netns i.e struct netns_ipvs
14  *              Affected data: est_list and est_lock.
15  *              estimation_timer() runs with timer per netns.
16  *              get_stats()) do the per cpu summing.
17  */
18
19 #define KMSG_COMPONENT "IPVS"
20 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
21
22 #include <linux/kernel.h>
23 #include <linux/jiffies.h>
24 #include <linux/types.h>
25 #include <linux/interrupt.h>
26 #include <linux/sysctl.h>
27 #include <linux/list.h>
28
29 #include <net/ip_vs.h>
30
31 /*
32   This code is to estimate rate in a shorter interval (such as 8
33   seconds) for virtual services and real servers. For measure rate in a
34   long interval, it is easy to implement a user level daemon which
35   periodically reads those statistical counters and measure rate.
36
37   Currently, the measurement is activated by slow timer handler. Hope
38   this measurement will not introduce too much load.
39
40   We measure rate during the last 8 seconds every 2 seconds:
41
42     avgrate = avgrate*(1-W) + rate*W
43
44     where W = 2^(-2)
45
46   NOTES.
47
48   * The stored value for average bps is scaled by 2^5, so that maximal
49     rate is ~2.15Gbits/s, average pps and cps are scaled by 2^10.
50
51   * A lot code is taken from net/sched/estimator.c
52  */
53
54
55 /*
56  * Make a summary from each cpu
57  */
58 static void ip_vs_read_cpu_stats(struct ip_vs_stats_user *sum,
59                                  struct ip_vs_cpu_stats *stats)
60 {
61         int i;
62
63         for_each_possible_cpu(i) {
64                 struct ip_vs_cpu_stats *s = per_cpu_ptr(stats, i);
65                 unsigned int start;
66                 __u64 inbytes, outbytes;
67                 if (i) {
68                         sum->conns += s->ustats.conns;
69                         sum->inpkts += s->ustats.inpkts;
70                         sum->outpkts += s->ustats.outpkts;
71                         do {
72                                 start = u64_stats_fetch_begin(&s->syncp);
73                                 inbytes = s->ustats.inbytes;
74                                 outbytes = s->ustats.outbytes;
75                         } while (u64_stats_fetch_retry(&s->syncp, start));
76                         sum->inbytes += inbytes;
77                         sum->outbytes += outbytes;
78                 } else {
79                         sum->conns = s->ustats.conns;
80                         sum->inpkts = s->ustats.inpkts;
81                         sum->outpkts = s->ustats.outpkts;
82                         do {
83                                 start = u64_stats_fetch_begin(&s->syncp);
84                                 sum->inbytes = s->ustats.inbytes;
85                                 sum->outbytes = s->ustats.outbytes;
86                         } while (u64_stats_fetch_retry(&s->syncp, start));
87                 }
88         }
89 }
90
91
92 static void estimation_timer(unsigned long arg)
93 {
94         struct ip_vs_estimator *e;
95         struct ip_vs_stats *s;
96         u32 n_conns;
97         u32 n_inpkts, n_outpkts;
98         u64 n_inbytes, n_outbytes;
99         u32 rate;
100         struct net *net = (struct net *)arg;
101         struct netns_ipvs *ipvs;
102
103         ipvs = net_ipvs(net);
104         ip_vs_read_cpu_stats(&ipvs->tot_stats->ustats, ipvs->cpustats);
105         spin_lock(&ipvs->est_lock);
106         list_for_each_entry(e, &ipvs->est_list, list) {
107                 s = container_of(e, struct ip_vs_stats, est);
108
109                 ip_vs_read_cpu_stats(&s->ustats, s->cpustats);
110                 spin_lock(&s->lock);
111                 n_conns = s->ustats.conns;
112                 n_inpkts = s->ustats.inpkts;
113                 n_outpkts = s->ustats.outpkts;
114                 n_inbytes = s->ustats.inbytes;
115                 n_outbytes = s->ustats.outbytes;
116
117                 /* scaled by 2^10, but divided 2 seconds */
118                 rate = (n_conns - e->last_conns) << 9;
119                 e->last_conns = n_conns;
120                 e->cps += ((long)rate - (long)e->cps) >> 2;
121                 s->ustats.cps = (e->cps + 0x1FF) >> 10;
122
123                 rate = (n_inpkts - e->last_inpkts) << 9;
124                 e->last_inpkts = n_inpkts;
125                 e->inpps += ((long)rate - (long)e->inpps) >> 2;
126                 s->ustats.inpps = (e->inpps + 0x1FF) >> 10;
127
128                 rate = (n_outpkts - e->last_outpkts) << 9;
129                 e->last_outpkts = n_outpkts;
130                 e->outpps += ((long)rate - (long)e->outpps) >> 2;
131                 s->ustats.outpps = (e->outpps + 0x1FF) >> 10;
132
133                 rate = (n_inbytes - e->last_inbytes) << 4;
134                 e->last_inbytes = n_inbytes;
135                 e->inbps += ((long)rate - (long)e->inbps) >> 2;
136                 s->ustats.inbps = (e->inbps + 0xF) >> 5;
137
138                 rate = (n_outbytes - e->last_outbytes) << 4;
139                 e->last_outbytes = n_outbytes;
140                 e->outbps += ((long)rate - (long)e->outbps) >> 2;
141                 s->ustats.outbps = (e->outbps + 0xF) >> 5;
142                 spin_unlock(&s->lock);
143         }
144         spin_unlock(&ipvs->est_lock);
145         mod_timer(&ipvs->est_timer, jiffies + 2*HZ);
146 }
147
148 void ip_vs_new_estimator(struct net *net, struct ip_vs_stats *stats)
149 {
150         struct netns_ipvs *ipvs = net_ipvs(net);
151         struct ip_vs_estimator *est = &stats->est;
152
153         INIT_LIST_HEAD(&est->list);
154
155         est->last_conns = stats->ustats.conns;
156         est->cps = stats->ustats.cps<<10;
157
158         est->last_inpkts = stats->ustats.inpkts;
159         est->inpps = stats->ustats.inpps<<10;
160
161         est->last_outpkts = stats->ustats.outpkts;
162         est->outpps = stats->ustats.outpps<<10;
163
164         est->last_inbytes = stats->ustats.inbytes;
165         est->inbps = stats->ustats.inbps<<5;
166
167         est->last_outbytes = stats->ustats.outbytes;
168         est->outbps = stats->ustats.outbps<<5;
169
170         spin_lock_bh(&ipvs->est_lock);
171         list_add(&est->list, &ipvs->est_list);
172         spin_unlock_bh(&ipvs->est_lock);
173 }
174
175 void ip_vs_kill_estimator(struct net *net, struct ip_vs_stats *stats)
176 {
177         struct netns_ipvs *ipvs = net_ipvs(net);
178         struct ip_vs_estimator *est = &stats->est;
179
180         spin_lock_bh(&ipvs->est_lock);
181         list_del(&est->list);
182         spin_unlock_bh(&ipvs->est_lock);
183 }
184
185 void ip_vs_zero_estimator(struct ip_vs_stats *stats)
186 {
187         struct ip_vs_estimator *est = &stats->est;
188
189         /* set counters zero, caller must hold the stats->lock lock */
190         est->last_inbytes = 0;
191         est->last_outbytes = 0;
192         est->last_conns = 0;
193         est->last_inpkts = 0;
194         est->last_outpkts = 0;
195         est->cps = 0;
196         est->inpps = 0;
197         est->outpps = 0;
198         est->inbps = 0;
199         est->outbps = 0;
200 }
201
202 static int __net_init __ip_vs_estimator_init(struct net *net)
203 {
204         struct netns_ipvs *ipvs = net_ipvs(net);
205
206         INIT_LIST_HEAD(&ipvs->est_list);
207         spin_lock_init(&ipvs->est_lock);
208         setup_timer(&ipvs->est_timer, estimation_timer, (unsigned long)net);
209         mod_timer(&ipvs->est_timer, jiffies + 2 * HZ);
210         return 0;
211 }
212
213 static void __net_exit __ip_vs_estimator_exit(struct net *net)
214 {
215         del_timer_sync(&net_ipvs(net)->est_timer);
216 }
217 static struct pernet_operations ip_vs_app_ops = {
218         .init = __ip_vs_estimator_init,
219         .exit = __ip_vs_estimator_exit,
220 };
221
222 int __init ip_vs_estimator_init(void)
223 {
224         int rv;
225
226         rv = register_pernet_subsys(&ip_vs_app_ops);
227         return rv;
228 }
229
230 void ip_vs_estimator_cleanup(void)
231 {
232         unregister_pernet_subsys(&ip_vs_app_ops);
233 }