1/* 2 * ip_vs_est.c: simple rate estimator for IPVS 3 * 4 * Version: $Id: ip_vs_est.c,v 1.1.1.1 2007/08/03 18:53:51 Exp $ 5 * 6 * Authors: Wensong Zhang <wensong@linuxvirtualserver.org> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * as published by the Free Software Foundation; either version 11 * 2 of the License, or (at your option) any later version. 12 * 13 * Changes: 14 * 15 */ 16#include <linux/kernel.h> 17#include <linux/jiffies.h> 18#include <linux/slab.h> 19#include <linux/types.h> 20#include <linux/interrupt.h> 21 22#include <net/ip_vs.h> 23 24/* 25 This code is to estimate rate in a shorter interval (such as 8 26 seconds) for virtual services and real servers. For measure rate in a 27 long interval, it is easy to implement a user level daemon which 28 periodically reads those statistical counters and measure rate. 29 30 Currently, the measurement is activated by slow timer handler. Hope 31 this measurement will not introduce too much load. 32 33 We measure rate during the last 8 seconds every 2 seconds: 34 35 avgrate = avgrate*(1-W) + rate*W 36 37 where W = 2^(-2) 38 39 NOTES. 40 41 * The stored value for average bps is scaled by 2^5, so that maximal 42 rate is ~2.15Gbits/s, average pps and cps are scaled by 2^10. 43 44 * A lot code is taken from net/sched/estimator.c 45 */ 46 47 48struct ip_vs_estimator 49{ 50 struct ip_vs_estimator *next; 51 struct ip_vs_stats *stats; 52 53 u32 last_conns; 54 u32 last_inpkts; 55 u32 last_outpkts; 56 u64 last_inbytes; 57 u64 last_outbytes; 58 59 u32 cps; 60 u32 inpps; 61 u32 outpps; 62 u32 inbps; 63 u32 outbps; 64}; 65 66 67static struct ip_vs_estimator *est_list = NULL; 68static DEFINE_RWLOCK(est_lock); 69static struct timer_list est_timer; 70 71static void estimation_timer(unsigned long arg) 72{ 73 struct ip_vs_estimator *e; 74 struct ip_vs_stats *s; 75 u32 n_conns; 76 u32 n_inpkts, n_outpkts; 77 u64 n_inbytes, n_outbytes; 78 u32 rate; 79 80 read_lock(&est_lock); 81 for (e = est_list; e; e = e->next) { 82 s = e->stats; 83 84 spin_lock(&s->lock); 85 n_conns = s->conns; 86 n_inpkts = s->inpkts; 87 n_outpkts = s->outpkts; 88 n_inbytes = s->inbytes; 89 n_outbytes = s->outbytes; 90 91 /* scaled by 2^10, but divided 2 seconds */ 92 rate = (n_conns - e->last_conns)<<9; 93 e->last_conns = n_conns; 94 e->cps += ((long)rate - (long)e->cps)>>2; 95 s->cps = (e->cps+0x1FF)>>10; 96 97 rate = (n_inpkts - e->last_inpkts)<<9; 98 e->last_inpkts = n_inpkts; 99 e->inpps += ((long)rate - (long)e->inpps)>>2; 100 s->inpps = (e->inpps+0x1FF)>>10; 101 102 rate = (n_outpkts - e->last_outpkts)<<9; 103 e->last_outpkts = n_outpkts; 104 e->outpps += ((long)rate - (long)e->outpps)>>2; 105 s->outpps = (e->outpps+0x1FF)>>10; 106 107 rate = (n_inbytes - e->last_inbytes)<<4; 108 e->last_inbytes = n_inbytes; 109 e->inbps += ((long)rate - (long)e->inbps)>>2; 110 s->inbps = (e->inbps+0xF)>>5; 111 112 rate = (n_outbytes - e->last_outbytes)<<4; 113 e->last_outbytes = n_outbytes; 114 e->outbps += ((long)rate - (long)e->outbps)>>2; 115 s->outbps = (e->outbps+0xF)>>5; 116 spin_unlock(&s->lock); 117 } 118 read_unlock(&est_lock); 119 mod_timer(&est_timer, jiffies + 2*HZ); 120} 121 122int ip_vs_new_estimator(struct ip_vs_stats *stats) 123{ 124 struct ip_vs_estimator *est; 125 126 est = kzalloc(sizeof(*est), GFP_KERNEL); 127 if (est == NULL) 128 return -ENOMEM; 129 130 est->stats = stats; 131 est->last_conns = stats->conns; 132 est->cps = stats->cps<<10; 133 134 est->last_inpkts = stats->inpkts; 135 est->inpps = stats->inpps<<10; 136 137 est->last_outpkts = stats->outpkts; 138 est->outpps = stats->outpps<<10; 139 140 est->last_inbytes = stats->inbytes; 141 est->inbps = stats->inbps<<5; 142 143 est->last_outbytes = stats->outbytes; 144 est->outbps = stats->outbps<<5; 145 146 write_lock_bh(&est_lock); 147 est->next = est_list; 148 if (est->next == NULL) { 149 init_timer(&est_timer); 150 est_timer.expires = jiffies + 2*HZ; 151 est_timer.function = estimation_timer; 152 add_timer(&est_timer); 153 } 154 est_list = est; 155 write_unlock_bh(&est_lock); 156 return 0; 157} 158 159void ip_vs_kill_estimator(struct ip_vs_stats *stats) 160{ 161 struct ip_vs_estimator *est, **pest; 162 int killed = 0; 163 164 write_lock_bh(&est_lock); 165 pest = &est_list; 166 while ((est=*pest) != NULL) { 167 if (est->stats != stats) { 168 pest = &est->next; 169 continue; 170 } 171 *pest = est->next; 172 kfree(est); 173 killed++; 174 } 175 if (killed && est_list == NULL) 176 del_timer_sync(&est_timer); 177 write_unlock_bh(&est_lock); 178} 179 180void ip_vs_zero_estimator(struct ip_vs_stats *stats) 181{ 182 struct ip_vs_estimator *e; 183 184 write_lock_bh(&est_lock); 185 for (e = est_list; e; e = e->next) { 186 if (e->stats != stats) 187 continue; 188 189 /* set counters zero */ 190 e->last_conns = 0; 191 e->last_inpkts = 0; 192 e->last_outpkts = 0; 193 e->last_inbytes = 0; 194 e->last_outbytes = 0; 195 e->cps = 0; 196 e->inpps = 0; 197 e->outpps = 0; 198 e->inbps = 0; 199 e->outbps = 0; 200 } 201 write_unlock_bh(&est_lock); 202} 203