linux-imx

/*

 * net/sched/sch_drr.c         Deficit Round Robin scheduler

 *

 * Copyright (c) 2008 Patrick McHardy <kaber@trash.net>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * version 2 as published by the Free Software Foundation.

 */

​

#include <linux/module.h>

#include <linux/slab.h>

#include <linux/init.h>

#include <linux/errno.h>

#include <linux/netdevice.h>

#include <linux/pkt_sched.h>

#include <net/sch_generic.h>

#include <net/pkt_sched.h>

#include <net/pkt_cls.h>

​

struct drr_class {

    struct Qdisc_class_common   common;

    unsigned int            filter_cnt;

​

    struct gnet_stats_basic_packed      bstats;

    struct gnet_stats_queue     qstats;

    struct net_rate_estimator __rcu *rate_est;

    struct list_head        alist;

    struct Qdisc            *qdisc;

​

    u32             quantum;

    u32             deficit;

};

​

struct drr_sched {

    struct list_head        active;

    struct tcf_proto __rcu      *filter_list;

    struct tcf_block        *block;

    struct Qdisc_class_hash     clhash;

};

​

static struct drr_class *drr_find_class(struct Qdisc *sch, u32 classid)

{

    struct drr_sched *q = qdisc_priv(sch);

    struct Qdisc_class_common *clc;

​

    clc = qdisc_class_find(&q->clhash, classid);

    if (clc == NULL)

        return NULL;

    return container_of(clc, struct drr_class, common);

}

​

static const struct nla_policy drr_policy[TCA_DRR_MAX + 1] = {

    [TCA_DRR_QUANTUM]   = { .type = NLA_U32 },

};

​

static int drr_change_class(struct Qdisc *sch, u32 classid, u32 parentid,

                struct nlattr **tca, unsigned long *arg,

                struct netlink_ext_ack *extack)

{

    struct drr_sched *q = qdisc_priv(sch);

    struct drr_class *cl = (struct drr_class *)*arg;

    struct nlattr *opt = tca[TCA_OPTIONS];

    struct nlattr *tb[TCA_DRR_MAX + 1];

    u32 quantum;

    int err;

​

    if (!opt) {

        NL_SET_ERR_MSG(extack, "DRR options are required for this operation");

        return -EINVAL;

    }

​

    err = nla_parse_nested(tb, TCA_DRR_MAX, opt, drr_policy, extack);

    if (err < 0)

        return err;

​

    if (tb[TCA_DRR_QUANTUM]) {

        quantum = nla_get_u32(tb[TCA_DRR_QUANTUM]);

        if (quantum == 0) {

            NL_SET_ERR_MSG(extack, "Specified DRR quantum cannot be zero");

            return -EINVAL;

        }

    } else

        quantum = psched_mtu(qdisc_dev(sch));

​

    if (cl != NULL) {

        if (tca[TCA_RATE]) {

            err = gen_replace_estimator(&cl->bstats, NULL,

                            &cl->rate_est,

                            NULL,

                            qdisc_root_sleeping_running(sch),

                            tca[TCA_RATE]);