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

TOMOYO Linux Cross Reference
Linux/net/core/gen_estimator.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ 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.75 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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  * net/sched/gen_estimator.c    Simple rate estimator.
  3  *
  4  *              This program is free software; you can redistribute it and/or
  5  *              modify it under the terms of the GNU General Public License
  6  *              as published by the Free Software Foundation; either version
  7  *              2 of the License, or (at your option) any later version.
  8  *
  9  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 10  *              Eric Dumazet <edumazet@google.com>
 11  *
 12  * Changes:
 13  *              Jamal Hadi Salim - moved it to net/core and reshulfed
 14  *              names to make it usable in general net subsystem.
 15  */
 16 
 17 #include <linux/uaccess.h>
 18 #include <linux/bitops.h>
 19 #include <linux/module.h>
 20 #include <linux/types.h>
 21 #include <linux/kernel.h>
 22 #include <linux/jiffies.h>
 23 #include <linux/string.h>
 24 #include <linux/mm.h>
 25 #include <linux/socket.h>
 26 #include <linux/sockios.h>
 27 #include <linux/in.h>
 28 #include <linux/errno.h>
 29 #include <linux/interrupt.h>
 30 #include <linux/netdevice.h>
 31 #include <linux/skbuff.h>
 32 #include <linux/rtnetlink.h>
 33 #include <linux/init.h>
 34 #include <linux/slab.h>
 35 #include <linux/seqlock.h>
 36 #include <net/sock.h>
 37 #include <net/gen_stats.h>
 38 
 39 /* This code is NOT intended to be used for statistics collection,
 40  * its purpose is to provide a base for statistical multiplexing
 41  * for controlled load service.
 42  * If you need only statistics, run a user level daemon which
 43  * periodically reads byte counters.
 44  */
 45 
 46 struct net_rate_estimator {
 47         struct gnet_stats_basic_packed  *bstats;
 48         spinlock_t              *stats_lock;
 49         seqcount_t              *running;
 50         struct gnet_stats_basic_cpu __percpu *cpu_bstats;
 51         u8                      ewma_log;
 52         u8                      intvl_log; /* period : (250ms << intvl_log) */
 53 
 54         seqcount_t              seq;
 55         u32                     last_packets;
 56         u64                     last_bytes;
 57 
 58         u64                     avpps;
 59         u64                     avbps;
 60 
 61         unsigned long           next_jiffies;
 62         struct timer_list       timer;
 63         struct rcu_head         rcu;
 64 };
 65 
 66 static void est_fetch_counters(struct net_rate_estimator *e,
 67                                struct gnet_stats_basic_packed *b)
 68 {
 69         memset(b, 0, sizeof(*b));
 70         if (e->stats_lock)
 71                 spin_lock(e->stats_lock);
 72 
 73         __gnet_stats_copy_basic(e->running, b, e->cpu_bstats, e->bstats);
 74 
 75         if (e->stats_lock)
 76                 spin_unlock(e->stats_lock);
 77 
 78 }
 79 
 80 static void est_timer(struct timer_list *t)
 81 {
 82         struct net_rate_estimator *est = from_timer(est, t, timer);
 83         struct gnet_stats_basic_packed b;
 84         u64 rate, brate;
 85 
 86         est_fetch_counters(est, &b);
 87         brate = (b.bytes - est->last_bytes) << (10 - est->ewma_log - est->intvl_log);
 88         brate -= (est->avbps >> est->ewma_log);
 89 
 90         rate = (u64)(b.packets - est->last_packets) << (10 - est->ewma_log - est->intvl_log);
 91         rate -= (est->avpps >> est->ewma_log);
 92 
 93         write_seqcount_begin(&est->seq);
 94         est->avbps += brate;
 95         est->avpps += rate;
 96         write_seqcount_end(&est->seq);
 97 
 98         est->last_bytes = b.bytes;
 99         est->last_packets = b.packets;
100 
101         est->next_jiffies += ((HZ/4) << est->intvl_log);
102 
103         if (unlikely(time_after_eq(jiffies, est->next_jiffies))) {
104                 /* Ouch... timer was delayed. */
105                 est->next_jiffies = jiffies + 1;
106         }
107         mod_timer(&est->timer, est->next_jiffies);
108 }
109 
110 /**
111  * gen_new_estimator - create a new rate estimator
112  * @bstats: basic statistics
113  * @cpu_bstats: bstats per cpu
114  * @rate_est: rate estimator statistics
115  * @stats_lock: statistics lock
116  * @running: qdisc running seqcount
117  * @opt: rate estimator configuration TLV
118  *
119  * Creates a new rate estimator with &bstats as source and &rate_est
120  * as destination. A new timer with the interval specified in the
121  * configuration TLV is created. Upon each interval, the latest statistics
122  * will be read from &bstats and the estimated rate will be stored in
123  * &rate_est with the statistics lock grabbed during this period.
124  *
125  * Returns 0 on success or a negative error code.
126  *
127  */
128 int gen_new_estimator(struct gnet_stats_basic_packed *bstats,
129                       struct gnet_stats_basic_cpu __percpu *cpu_bstats,
130                       struct net_rate_estimator __rcu **rate_est,
131                       spinlock_t *stats_lock,
132                       seqcount_t *running,
133                       struct nlattr *opt)
134 {
135         struct gnet_estimator *parm = nla_data(opt);
136         struct net_rate_estimator *old, *est;
137         struct gnet_stats_basic_packed b;
138         int intvl_log;
139 
140         if (nla_len(opt) < sizeof(*parm))
141                 return -EINVAL;
142 
143         /* allowed timer periods are :
144          * -2 : 250ms,   -1 : 500ms,    0 : 1 sec
145          *  1 : 2 sec,    2 : 4 sec,    3 : 8 sec
146          */
147         if (parm->interval < -2 || parm->interval > 3)
148                 return -EINVAL;
149 
150         est = kzalloc(sizeof(*est), GFP_KERNEL);
151         if (!est)
152                 return -ENOBUFS;
153 
154         seqcount_init(&est->seq);
155         intvl_log = parm->interval + 2;
156         est->bstats = bstats;
157         est->stats_lock = stats_lock;
158         est->running  = running;
159         est->ewma_log = parm->ewma_log;
160         est->intvl_log = intvl_log;
161         est->cpu_bstats = cpu_bstats;
162 
163         if (stats_lock)
164                 local_bh_disable();
165         est_fetch_counters(est, &b);
166         if (stats_lock)
167                 local_bh_enable();
168         est->last_bytes = b.bytes;
169         est->last_packets = b.packets;
170         old = rcu_dereference_protected(*rate_est, 1);
171         if (old) {
172                 del_timer_sync(&old->timer);
173                 est->avbps = old->avbps;
174                 est->avpps = old->avpps;
175         }
176 
177         est->next_jiffies = jiffies + ((HZ/4) << intvl_log);
178         timer_setup(&est->timer, est_timer, 0);
179         mod_timer(&est->timer, est->next_jiffies);
180 
181         rcu_assign_pointer(*rate_est, est);
182         if (old)
183                 kfree_rcu(old, rcu);
184         return 0;
185 }
186 EXPORT_SYMBOL(gen_new_estimator);
187 
188 /**
189  * gen_kill_estimator - remove a rate estimator
190  * @rate_est: rate estimator
191  *
192  * Removes the rate estimator.
193  *
194  */
195 void gen_kill_estimator(struct net_rate_estimator __rcu **rate_est)
196 {
197         struct net_rate_estimator *est;
198 
199         est = xchg((__force struct net_rate_estimator **)rate_est, NULL);
200         if (est) {
201                 del_timer_sync(&est->timer);
202                 kfree_rcu(est, rcu);
203         }
204 }
205 EXPORT_SYMBOL(gen_kill_estimator);
206 
207 /**
208  * gen_replace_estimator - replace rate estimator configuration
209  * @bstats: basic statistics
210  * @cpu_bstats: bstats per cpu
211  * @rate_est: rate estimator statistics
212  * @stats_lock: statistics lock
213  * @running: qdisc running seqcount (might be NULL)
214  * @opt: rate estimator configuration TLV
215  *
216  * Replaces the configuration of a rate estimator by calling
217  * gen_kill_estimator() and gen_new_estimator().
218  *
219  * Returns 0 on success or a negative error code.
220  */
221 int gen_replace_estimator(struct gnet_stats_basic_packed *bstats,
222                           struct gnet_stats_basic_cpu __percpu *cpu_bstats,
223                           struct net_rate_estimator __rcu **rate_est,
224                           spinlock_t *stats_lock,
225                           seqcount_t *running, struct nlattr *opt)
226 {
227         return gen_new_estimator(bstats, cpu_bstats, rate_est,
228                                  stats_lock, running, opt);
229 }
230 EXPORT_SYMBOL(gen_replace_estimator);
231 
232 /**
233  * gen_estimator_active - test if estimator is currently in use
234  * @rate_est: rate estimator
235  *
236  * Returns true if estimator is active, and false if not.
237  */
238 bool gen_estimator_active(struct net_rate_estimator __rcu **rate_est)
239 {
240         return !!rcu_access_pointer(*rate_est);
241 }
242 EXPORT_SYMBOL(gen_estimator_active);
243 
244 bool gen_estimator_read(struct net_rate_estimator __rcu **rate_est,
245                         struct gnet_stats_rate_est64 *sample)
246 {
247         struct net_rate_estimator *est;
248         unsigned seq;
249 
250         rcu_read_lock();
251         est = rcu_dereference(*rate_est);
252         if (!est) {
253                 rcu_read_unlock();
254                 return false;
255         }
256 
257         do {
258                 seq = read_seqcount_begin(&est->seq);
259                 sample->bps = est->avbps >> 8;
260                 sample->pps = est->avpps >> 8;
261         } while (read_seqcount_retry(&est->seq, seq));
262 
263         rcu_read_unlock();
264         return true;
265 }
266 EXPORT_SYMBOL(gen_estimator_read);
267 

~ [ 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