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