IPVS: init and cleanup restructuring
[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         spin_lock(&ipvs->est_lock);
105         list_for_each_entry(e, &ipvs->est_list, list) {
106                 s = container_of(e, struct ip_vs_stats, est);
107
108                 spin_lock(&s->lock);
109                 ip_vs_read_cpu_stats(&s->ustats, s->cpustats);
110                 n_conns = s->ustats.conns;
111                 n_inpkts = s->ustats.inpkts;
112                 n_outpkts = s->ustats.outpkts;
113                 n_inbytes = s->ustats.inbytes;
114                 n_outbytes = s->ustats.outbytes;
115
116                 /* scaled by 2^10, but divided 2 seconds */
117                 rate = (n_conns - e->last_conns) << 9;
118                 e->last_conns = n_conns;
119                 e->cps += ((long)rate - (long)e->cps) >> 2;
120
121                 rate = (n_inpkts - e->last_inpkts) << 9;
122                 e->last_inpkts = n_inpkts;
123                 e->inpps += ((long)rate - (long)e->inpps) >> 2;
124
125                 rate = (n_outpkts - e->last_outpkts) << 9;
126                 e->last_outpkts = n_outpkts;
127                 e->outpps += ((long)rate - (long)e->outpps) >> 2;
128
129                 rate = (n_inbytes - e->last_inbytes) << 4;
130                 e->last_inbytes = n_inbytes;
131                 e->inbps += ((long)rate - (long)e->inbps) >> 2;
132
133                 rate = (n_outbytes - e->last_outbytes) << 4;
134                 e->last_outbytes = n_outbytes;
135                 e->outbps += ((long)rate - (long)e->outbps) >> 2;
136                 spin_unlock(&s->lock);
137         }
138         spin_unlock(&ipvs->est_lock);
139         mod_timer(&ipvs->est_timer, jiffies + 2*HZ);
140 }
141
142 void ip_vs_start_estimator(struct net *net, struct ip_vs_stats *stats)
143 {
144         struct netns_ipvs *ipvs = net_ipvs(net);
145         struct ip_vs_estimator *est = &stats->est;
146
147         INIT_LIST_HEAD(&est->list);
148
149         spin_lock_bh(&ipvs->est_lock);
150         list_add(&est->list, &ipvs->est_list);
151         spin_unlock_bh(&ipvs->est_lock);
152 }
153
154 void ip_vs_stop_estimator(struct net *net, struct ip_vs_stats *stats)
155 {
156         struct netns_ipvs *ipvs = net_ipvs(net);
157         struct ip_vs_estimator *est = &stats->est;
158
159         spin_lock_bh(&ipvs->est_lock);
160         list_del(&est->list);
161         spin_unlock_bh(&ipvs->est_lock);
162 }
163
164 void ip_vs_zero_estimator(struct ip_vs_stats *stats)
165 {
166         struct ip_vs_estimator *est = &stats->est;
167         struct ip_vs_stats_user *u = &stats->ustats;
168
169         /* reset counters, caller must hold the stats->lock lock */
170         est->last_inbytes = u->inbytes;
171         est->last_outbytes = u->outbytes;
172         est->last_conns = u->conns;
173         est->last_inpkts = u->inpkts;
174         est->last_outpkts = u->outpkts;
175         est->cps = 0;
176         est->inpps = 0;
177         est->outpps = 0;
178         est->inbps = 0;
179         est->outbps = 0;
180 }
181
182 /* Get decoded rates */
183 void ip_vs_read_estimator(struct ip_vs_stats_user *dst,
184                           struct ip_vs_stats *stats)
185 {
186         struct ip_vs_estimator *e = &stats->est;
187
188         dst->cps = (e->cps + 0x1FF) >> 10;
189         dst->inpps = (e->inpps + 0x1FF) >> 10;
190         dst->outpps = (e->outpps + 0x1FF) >> 10;
191         dst->inbps = (e->inbps + 0xF) >> 5;
192         dst->outbps = (e->outbps + 0xF) >> 5;
193 }
194
195 int __net_init __ip_vs_estimator_init(struct net *net)
196 {
197         struct netns_ipvs *ipvs = net_ipvs(net);
198
199         INIT_LIST_HEAD(&ipvs->est_list);
200         spin_lock_init(&ipvs->est_lock);
201         setup_timer(&ipvs->est_timer, estimation_timer, (unsigned long)net);
202         mod_timer(&ipvs->est_timer, jiffies + 2 * HZ);
203         return 0;
204 }
205
206 void __net_exit __ip_vs_estimator_cleanup(struct net *net)
207 {
208         del_timer_sync(&net_ipvs(net)->est_timer);
209 }
210
211 int __init ip_vs_estimator_init(void)
212 {
213         return 0;
214 }
215
216 void ip_vs_estimator_cleanup(void)
217 {
218 }