~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/netfilter/ipvs/ip_vs_est.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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   * Average bps is scaled by 2^5, while average pps and cps are scaled by 2^10.
 49 
 50   * Netlink users can see 64-bit values but sockopt users are restricted
 51     to 32-bit values for conns, packets, bps, cps and pps.
 52 
 53   * A lot of code is taken from net/core/gen_estimator.c
 54  */
 55 
 56 
 57 /*
 58  * Make a summary from each cpu
 59  */
 60 static void ip_vs_read_cpu_stats(struct ip_vs_kstats *sum,
 61                                  struct ip_vs_cpu_stats __percpu *stats)
 62 {
 63         int i;
 64         bool add = false;
 65 
 66         for_each_possible_cpu(i) {
 67                 struct ip_vs_cpu_stats *s = per_cpu_ptr(stats, i);
 68                 unsigned int start;
 69                 u64 conns, inpkts, outpkts, inbytes, outbytes;
 70 
 71                 if (add) {
 72                         do {
 73                                 start = u64_stats_fetch_begin(&s->syncp);
 74                                 conns = s->cnt.conns;
 75                                 inpkts = s->cnt.inpkts;
 76                                 outpkts = s->cnt.outpkts;
 77                                 inbytes = s->cnt.inbytes;
 78                                 outbytes = s->cnt.outbytes;
 79                         } while (u64_stats_fetch_retry(&s->syncp, start));
 80                         sum->conns += conns;
 81                         sum->inpkts += inpkts;
 82                         sum->outpkts += outpkts;
 83                         sum->inbytes += inbytes;
 84                         sum->outbytes += outbytes;
 85                 } else {
 86                         add = true;
 87                         do {
 88                                 start = u64_stats_fetch_begin(&s->syncp);
 89                                 sum->conns = s->cnt.conns;
 90                                 sum->inpkts = s->cnt.inpkts;
 91                                 sum->outpkts = s->cnt.outpkts;
 92                                 sum->inbytes = s->cnt.inbytes;
 93                                 sum->outbytes = s->cnt.outbytes;
 94                         } while (u64_stats_fetch_retry(&s->syncp, start));
 95                 }
 96         }
 97 }
 98 
 99 
100 static void estimation_timer(unsigned long arg)
101 {
102         struct ip_vs_estimator *e;
103         struct ip_vs_stats *s;
104         u64 rate;
105         struct netns_ipvs *ipvs = (struct netns_ipvs *)arg;
106 
107         spin_lock(&ipvs->est_lock);
108         list_for_each_entry(e, &ipvs->est_list, list) {
109                 s = container_of(e, struct ip_vs_stats, est);
110 
111                 spin_lock(&s->lock);
112                 ip_vs_read_cpu_stats(&s->kstats, s->cpustats);
113 
114                 /* scaled by 2^10, but divided 2 seconds */
115                 rate = (s->kstats.conns - e->last_conns) << 9;
116                 e->last_conns = s->kstats.conns;
117                 e->cps += ((s64)rate - (s64)e->cps) >> 2;
118 
119                 rate = (s->kstats.inpkts - e->last_inpkts) << 9;
120                 e->last_inpkts = s->kstats.inpkts;
121                 e->inpps += ((s64)rate - (s64)e->inpps) >> 2;
122 
123                 rate = (s->kstats.outpkts - e->last_outpkts) << 9;
124                 e->last_outpkts = s->kstats.outpkts;
125                 e->outpps += ((s64)rate - (s64)e->outpps) >> 2;
126 
127                 /* scaled by 2^5, but divided 2 seconds */
128                 rate = (s->kstats.inbytes - e->last_inbytes) << 4;
129                 e->last_inbytes = s->kstats.inbytes;
130                 e->inbps += ((s64)rate - (s64)e->inbps) >> 2;
131 
132                 rate = (s->kstats.outbytes - e->last_outbytes) << 4;
133                 e->last_outbytes = s->kstats.outbytes;
134                 e->outbps += ((s64)rate - (s64)e->outbps) >> 2;
135                 spin_unlock(&s->lock);
136         }
137         spin_unlock(&ipvs->est_lock);
138         mod_timer(&ipvs->est_timer, jiffies + 2*HZ);
139 }
140 
141 void ip_vs_start_estimator(struct netns_ipvs *ipvs, struct ip_vs_stats *stats)
142 {
143         struct ip_vs_estimator *est = &stats->est;
144 
145         INIT_LIST_HEAD(&est->list);
146 
147         spin_lock_bh(&ipvs->est_lock);
148         list_add(&est->list, &ipvs->est_list);
149         spin_unlock_bh(&ipvs->est_lock);
150 }
151 
152 void ip_vs_stop_estimator(struct netns_ipvs *ipvs, struct ip_vs_stats *stats)
153 {
154         struct ip_vs_estimator *est = &stats->est;
155 
156         spin_lock_bh(&ipvs->est_lock);
157         list_del(&est->list);
158         spin_unlock_bh(&ipvs->est_lock);
159 }
160 
161 void ip_vs_zero_estimator(struct ip_vs_stats *stats)
162 {
163         struct ip_vs_estimator *est = &stats->est;
164         struct ip_vs_kstats *k = &stats->kstats;
165 
166         /* reset counters, caller must hold the stats->lock lock */
167         est->last_inbytes = k->inbytes;
168         est->last_outbytes = k->outbytes;
169         est->last_conns = k->conns;
170         est->last_inpkts = k->inpkts;
171         est->last_outpkts = k->outpkts;
172         est->cps = 0;
173         est->inpps = 0;
174         est->outpps = 0;
175         est->inbps = 0;
176         est->outbps = 0;
177 }
178 
179 /* Get decoded rates */
180 void ip_vs_read_estimator(struct ip_vs_kstats *dst, struct ip_vs_stats *stats)
181 {
182         struct ip_vs_estimator *e = &stats->est;
183 
184         dst->cps = (e->cps + 0x1FF) >> 10;
185         dst->inpps = (e->inpps + 0x1FF) >> 10;
186         dst->outpps = (e->outpps + 0x1FF) >> 10;
187         dst->inbps = (e->inbps + 0xF) >> 5;
188         dst->outbps = (e->outbps + 0xF) >> 5;
189 }
190 
191 int __net_init ip_vs_estimator_net_init(struct netns_ipvs *ipvs)
192 {
193         INIT_LIST_HEAD(&ipvs->est_list);
194         spin_lock_init(&ipvs->est_lock);
195         setup_timer(&ipvs->est_timer, estimation_timer, (unsigned long)ipvs);
196         mod_timer(&ipvs->est_timer, jiffies + 2 * HZ);
197         return 0;
198 }
199 
200 void __net_exit ip_vs_estimator_net_cleanup(struct netns_ipvs *ipvs)
201 {
202         del_timer_sync(&ipvs->est_timer);
203 }
204 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp