Quelle  gen_estimator.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * net/sched/gen_estimator.c Simple rate estimator.
 *
 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 *  Eric Dumazet <edumazet@google.com>
 *
 * Changes:
 *              Jamal Hadi Salim - moved it to net/core and reshulfed
 *              names to make it usable in general net subsystem.
 */

#include <linux/uaccess.h>
#include <linux/bitops.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/jiffies.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/in.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/rtnetlink.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/seqlock.h>
#include <net/sock.h>
#include <net/gen_stats.h>

/* This code is NOT intended to be used for statistics collection,
 * its purpose is to provide a base for statistical multiplexing
 * for controlled load service.
 * If you need only statistics, run a user level daemon which
 * periodically reads byte counters.
 */

struct net_rate_estimator {
 struct gnet_stats_basic_sync *bstats;
 spinlock_t  *stats_lock;
 bool   running;
 struct gnet_stats_basic_sync __percpu *cpu_bstats;
 u8   ewma_log;
 u8   intvl_log; /* period : (250ms << intvl_log) */

 seqcount_t  seq;
 u64   last_packets;
 u64   last_bytes;

 u64   avpps;
 u64   avbps;

 unsigned long           next_jiffies;
 struct timer_list       timer;
 struct rcu_head  rcu;
};

static void est_fetch_counters(struct net_rate_estimator *e,
          struct gnet_stats_basic_sync *b)
{
 gnet_stats_basic_sync_init(b);
 if (e->stats_lock)
  spin_lock(e->stats_lock);

 gnet_stats_add_basic(b, e->cpu_bstats, e->bstats, e->running);

 if (e->stats_lock)
  spin_unlock(e->stats_lock);

}

static void est_timer(struct timer_list *t)
{
 struct net_rate_estimator *est = timer_container_of(est, t, timer);
 struct gnet_stats_basic_sync b;
 u64 b_bytes, b_packets;
 u64 rate, brate;

 est_fetch_counters(est, &b);
 b_bytes = u64_stats_read(&b.bytes);
 b_packets = u64_stats_read(&b.packets);

 brate = (b_bytes - est->last_bytes) << (10 - est->intvl_log);
 brate = (brate >> est->ewma_log) - (est->avbps >> est->ewma_log);

 rate = (b_packets - est->last_packets) << (10 - est->intvl_log);
 rate = (rate >> est->ewma_log) - (est->avpps >> est->ewma_log);

 preempt_disable_nested();
 write_seqcount_begin(&est->seq);
 est->avbps += brate;
 est->avpps += rate;
 write_seqcount_end(&est->seq);
 preempt_enable_nested();

 est->last_bytes = b_bytes;
 est->last_packets = b_packets;

 est->next_jiffies += ((HZ/4) << est->intvl_log);

 if (unlikely(time_after_eq(jiffies, est->next_jiffies))) {
  /* Ouch... timer was delayed. */
  est->next_jiffies = jiffies + 1;
 }
 mod_timer(&est->timer, est->next_jiffies);
}

/**
 * gen_new_estimator - create a new rate estimator
 * @bstats: basic statistics
 * @cpu_bstats: bstats per cpu
 * @rate_est: rate estimator statistics
 * @lock: lock for statistics and control path
 * @running: true if @bstats represents a running qdisc, thus @bstats'
 *           internal values might change during basic reads. Only used
 *           if @bstats_cpu is NULL
 * @opt: rate estimator configuration TLV
 *
 * Creates a new rate estimator with &bstats as source and &rate_est
 * as destination. A new timer with the interval specified in the
 * configuration TLV is created. Upon each interval, the latest statistics
 * will be read from &bstats and the estimated rate will be stored in
 * &rate_est with the statistics lock grabbed during this period.
 *
 * Returns 0 on success or a negative error code.
 *
 */
int gen_new_estimator(struct gnet_stats_basic_sync *bstats,
        struct gnet_stats_basic_sync __percpu *cpu_bstats,
        struct net_rate_estimator __rcu **rate_est,
        spinlock_t *lock,
        bool running,
        struct nlattr *opt)
{
 struct gnet_estimator *parm = nla_data(opt);
 struct net_rate_estimator *old, *est;
 struct gnet_stats_basic_sync b;
 int intvl_log;

 if (nla_len(opt) < sizeof(*parm))
  return -EINVAL;

 /* allowed timer periods are :
  * -2 : 250ms,   -1 : 500ms,    0 : 1 sec
  *  1 : 2 sec,    2 : 4 sec,    3 : 8 sec
 */
 if (parm->interval < -2 || parm->interval > 3)
  return -EINVAL;

 if (parm->ewma_log == 0 || parm->ewma_log >= 31)
  return -EINVAL;

 est = kzalloc(sizeof(*est), GFP_KERNEL);
 if (!est)
  return -ENOBUFS;

 seqcount_init(&est->seq);
 intvl_log = parm->interval + 2;
 est->bstats = bstats;
 est->stats_lock = lock;
 est->running  = running;
 est->ewma_log = parm->ewma_log;
 est->intvl_log = intvl_log;
 est->cpu_bstats = cpu_bstats;

 if (lock)
  local_bh_disable();
 est_fetch_counters(est, &b);
 if (lock)
  local_bh_enable();
 est->last_bytes = u64_stats_read(&b.bytes);
 est->last_packets = u64_stats_read(&b.packets);

 if (lock)
  spin_lock_bh(lock);
 old = rcu_dereference_protected(*rate_est, 1);
 if (old) {
  timer_delete_sync(&old->timer);
  est->avbps = old->avbps;
  est->avpps = old->avpps;
 }

 est->next_jiffies = jiffies + ((HZ/4) << intvl_log);
 timer_setup(&est->timer, est_timer, 0);
 mod_timer(&est->timer, est->next_jiffies);

 rcu_assign_pointer(*rate_est, est);
 if (lock)
  spin_unlock_bh(lock);
 if (old)
  kfree_rcu(old, rcu);
 return 0;
}
EXPORT_SYMBOL(gen_new_estimator);

/**
 * gen_kill_estimator - remove a rate estimator
 * @rate_est: rate estimator
 *
 * Removes the rate estimator.
 *
 */
void gen_kill_estimator(struct net_rate_estimator __rcu **rate_est)
{
 struct net_rate_estimator *est;

 est = unrcu_pointer(xchg(rate_est, NULL));
 if (est) {
  timer_shutdown_sync(&est->timer);
  kfree_rcu(est, rcu);
 }
}
EXPORT_SYMBOL(gen_kill_estimator);

/**
 * gen_replace_estimator - replace rate estimator configuration
 * @bstats: basic statistics
 * @cpu_bstats: bstats per cpu
 * @rate_est: rate estimator statistics
 * @lock: lock for statistics and control path
 * @running: true if @bstats represents a running qdisc, thus @bstats'
 *           internal values might change during basic reads. Only used
 *           if @cpu_bstats is NULL
 * @opt: rate estimator configuration TLV
 *
 * Replaces the configuration of a rate estimator by calling
 * gen_kill_estimator() and gen_new_estimator().
 *
 * Returns 0 on success or a negative error code.
 */
int gen_replace_estimator(struct gnet_stats_basic_sync *bstats,
     struct gnet_stats_basic_sync __percpu *cpu_bstats,
     struct net_rate_estimator __rcu **rate_est,
     spinlock_t *lock,
     bool running, struct nlattr *opt)
{
 return gen_new_estimator(bstats, cpu_bstats, rate_est,
     lock, running, opt);
}
EXPORT_SYMBOL(gen_replace_estimator);

/**
 * gen_estimator_active - test if estimator is currently in use
 * @rate_est: rate estimator
 *
 * Returns true if estimator is active, and false if not.
 */
bool gen_estimator_active(struct net_rate_estimator __rcu **rate_est)
{
 return !!rcu_access_pointer(*rate_est);
}
EXPORT_SYMBOL(gen_estimator_active);

bool gen_estimator_read(struct net_rate_estimator __rcu **rate_est,
   struct gnet_stats_rate_est64 *sample)
{
 struct net_rate_estimator *est;
 unsigned seq;

 rcu_read_lock();
 est = rcu_dereference(*rate_est);
 if (!est) {
  rcu_read_unlock();
  return false;
 }

 do {
  seq = read_seqcount_begin(&est->seq);
  sample->bps = est->avbps >> 8;
  sample->pps = est->avpps >> 8;
 } while (read_seqcount_retry(&est->seq, seq));

 rcu_read_unlock();
 return true;
}
EXPORT_SYMBOL(gen_estimator_read);