linux/net/sched/sch_multiq.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2008, Intel Corporation.
   3 *
   4 * This program is free software; you can redistribute it and/or modify it
   5 * under the terms and conditions of the GNU General Public License,
   6 * version 2, as published by the Free Software Foundation.
   7 *
   8 * This program is distributed in the hope it will be useful, but WITHOUT
   9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11 * more details.
  12 *
  13 * You should have received a copy of the GNU General Public License along with
  14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  15 * Place - Suite 330, Boston, MA 02111-1307 USA.
  16 *
  17 * Author: Alexander Duyck <alexander.h.duyck@intel.com>
  18 */
  19
  20#include <linux/module.h>
  21#include <linux/slab.h>
  22#include <linux/types.h>
  23#include <linux/kernel.h>
  24#include <linux/string.h>
  25#include <linux/errno.h>
  26#include <linux/skbuff.h>
  27#include <net/netlink.h>
  28#include <net/pkt_sched.h>
  29
  30
  31struct multiq_sched_data {
  32        u16 bands;
  33        u16 max_bands;
  34        u16 curband;
  35        struct tcf_proto *filter_list;
  36        struct Qdisc **queues;
  37};
  38
  39
  40static struct Qdisc *
  41multiq_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)
  42{
  43        struct multiq_sched_data *q = qdisc_priv(sch);
  44        u32 band;
  45        struct tcf_result res;
  46        int err;
  47
  48        *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
  49        err = tc_classify(skb, q->filter_list, &res);
  50#ifdef CONFIG_NET_CLS_ACT
  51        switch (err) {
  52        case TC_ACT_STOLEN:
  53        case TC_ACT_QUEUED:
  54                *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
  55        case TC_ACT_SHOT:
  56                return NULL;
  57        }
  58#endif
  59        band = skb_get_queue_mapping(skb);
  60
  61        if (band >= q->bands)
  62                return q->queues[0];
  63
  64        return q->queues[band];
  65}
  66
  67static int
  68multiq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
  69{
  70        struct Qdisc *qdisc;
  71        int ret;
  72
  73        qdisc = multiq_classify(skb, sch, &ret);
  74#ifdef CONFIG_NET_CLS_ACT
  75        if (qdisc == NULL) {
  76
  77                if (ret & __NET_XMIT_BYPASS)
  78                        sch->qstats.drops++;
  79                kfree_skb(skb);
  80                return ret;
  81        }
  82#endif
  83
  84        ret = qdisc_enqueue(skb, qdisc);
  85        if (ret == NET_XMIT_SUCCESS) {
  86                sch->q.qlen++;
  87                return NET_XMIT_SUCCESS;
  88        }
  89        if (net_xmit_drop_count(ret))
  90                sch->qstats.drops++;
  91        return ret;
  92}
  93
  94static struct sk_buff *multiq_dequeue(struct Qdisc *sch)
  95{
  96        struct multiq_sched_data *q = qdisc_priv(sch);
  97        struct Qdisc *qdisc;
  98        struct sk_buff *skb;
  99        int band;
 100
 101        for (band = 0; band < q->bands; band++) {
 102                /* cycle through bands to ensure fairness */
 103                q->curband++;
 104                if (q->curband >= q->bands)
 105                        q->curband = 0;
 106
 107                /* Check that target subqueue is available before
 108                 * pulling an skb to avoid head-of-line blocking.
 109                 */
 110                if (!netif_xmit_stopped(
 111                    netdev_get_tx_queue(qdisc_dev(sch), q->curband))) {
 112                        qdisc = q->queues[q->curband];
 113                        skb = qdisc->dequeue(qdisc);
 114                        if (skb) {
 115                                qdisc_bstats_update(sch, skb);
 116                                sch->q.qlen--;
 117                                return skb;
 118                        }
 119                }
 120        }
 121        return NULL;
 122
 123}
 124
 125static struct sk_buff *multiq_peek(struct Qdisc *sch)
 126{
 127        struct multiq_sched_data *q = qdisc_priv(sch);
 128        unsigned int curband = q->curband;
 129        struct Qdisc *qdisc;
 130        struct sk_buff *skb;
 131        int band;
 132
 133        for (band = 0; band < q->bands; band++) {
 134                /* cycle through bands to ensure fairness */
 135                curband++;
 136                if (curband >= q->bands)
 137                        curband = 0;
 138
 139                /* Check that target subqueue is available before
 140                 * pulling an skb to avoid head-of-line blocking.
 141                 */
 142                if (!netif_xmit_stopped(
 143                    netdev_get_tx_queue(qdisc_dev(sch), curband))) {
 144                        qdisc = q->queues[curband];
 145                        skb = qdisc->ops->peek(qdisc);
 146                        if (skb)
 147                                return skb;
 148                }
 149        }
 150        return NULL;
 151
 152}
 153
 154static unsigned int multiq_drop(struct Qdisc *sch)
 155{
 156        struct multiq_sched_data *q = qdisc_priv(sch);
 157        int band;
 158        unsigned int len;
 159        struct Qdisc *qdisc;
 160
 161        for (band = q->bands - 1; band >= 0; band--) {
 162                qdisc = q->queues[band];
 163                if (qdisc->ops->drop) {
 164                        len = qdisc->ops->drop(qdisc);
 165                        if (len != 0) {
 166                                sch->q.qlen--;
 167                                return len;
 168                        }
 169                }
 170        }
 171        return 0;
 172}
 173
 174
 175static void
 176multiq_reset(struct Qdisc *sch)
 177{
 178        u16 band;
 179        struct multiq_sched_data *q = qdisc_priv(sch);
 180
 181        for (band = 0; band < q->bands; band++)
 182                qdisc_reset(q->queues[band]);
 183        sch->q.qlen = 0;
 184        q->curband = 0;
 185}
 186
 187static void
 188multiq_destroy(struct Qdisc *sch)
 189{
 190        int band;
 191        struct multiq_sched_data *q = qdisc_priv(sch);
 192
 193        tcf_destroy_chain(&q->filter_list);
 194        for (band = 0; band < q->bands; band++)
 195                qdisc_destroy(q->queues[band]);
 196
 197        kfree(q->queues);
 198}
 199
 200static int multiq_tune(struct Qdisc *sch, struct nlattr *opt)
 201{
 202        struct multiq_sched_data *q = qdisc_priv(sch);
 203        struct tc_multiq_qopt *qopt;
 204        int i;
 205
 206        if (!netif_is_multiqueue(qdisc_dev(sch)))
 207                return -EOPNOTSUPP;
 208        if (nla_len(opt) < sizeof(*qopt))
 209                return -EINVAL;
 210
 211        qopt = nla_data(opt);
 212
 213        qopt->bands = qdisc_dev(sch)->real_num_tx_queues;
 214
 215        sch_tree_lock(sch);
 216        q->bands = qopt->bands;
 217        for (i = q->bands; i < q->max_bands; i++) {
 218                if (q->queues[i] != &noop_qdisc) {
 219                        struct Qdisc *child = q->queues[i];
 220                        q->queues[i] = &noop_qdisc;
 221                        qdisc_tree_decrease_qlen(child, child->q.qlen);
 222                        qdisc_destroy(child);
 223                }
 224        }
 225
 226        sch_tree_unlock(sch);
 227
 228        for (i = 0; i < q->bands; i++) {
 229                if (q->queues[i] == &noop_qdisc) {
 230                        struct Qdisc *child, *old;
 231                        child = qdisc_create_dflt(sch->dev_queue,
 232                                                  &pfifo_qdisc_ops,
 233                                                  TC_H_MAKE(sch->handle,
 234                                                            i + 1));
 235                        if (child) {
 236                                sch_tree_lock(sch);
 237                                old = q->queues[i];
 238                                q->queues[i] = child;
 239
 240                                if (old != &noop_qdisc) {
 241                                        qdisc_tree_decrease_qlen(old,
 242                                                                 old->q.qlen);
 243                                        qdisc_destroy(old);
 244                                }
 245                                sch_tree_unlock(sch);
 246                        }
 247                }
 248        }
 249        return 0;
 250}
 251
 252static int multiq_init(struct Qdisc *sch, struct nlattr *opt)
 253{
 254        struct multiq_sched_data *q = qdisc_priv(sch);
 255        int i, err;
 256
 257        q->queues = NULL;
 258
 259        if (opt == NULL)
 260                return -EINVAL;
 261
 262        q->max_bands = qdisc_dev(sch)->num_tx_queues;
 263
 264        q->queues = kcalloc(q->max_bands, sizeof(struct Qdisc *), GFP_KERNEL);
 265        if (!q->queues)
 266                return -ENOBUFS;
 267        for (i = 0; i < q->max_bands; i++)
 268                q->queues[i] = &noop_qdisc;
 269
 270        err = multiq_tune(sch, opt);
 271
 272        if (err)
 273                kfree(q->queues);
 274
 275        return err;
 276}
 277
 278static int multiq_dump(struct Qdisc *sch, struct sk_buff *skb)
 279{
 280        struct multiq_sched_data *q = qdisc_priv(sch);
 281        unsigned char *b = skb_tail_pointer(skb);
 282        struct tc_multiq_qopt opt;
 283
 284        opt.bands = q->bands;
 285        opt.max_bands = q->max_bands;
 286
 287        if (nla_put(skb, TCA_OPTIONS, sizeof(opt), &opt))
 288                goto nla_put_failure;
 289
 290        return skb->len;
 291
 292nla_put_failure:
 293        nlmsg_trim(skb, b);
 294        return -1;
 295}
 296
 297static int multiq_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
 298                      struct Qdisc **old)
 299{
 300        struct multiq_sched_data *q = qdisc_priv(sch);
 301        unsigned long band = arg - 1;
 302
 303        if (new == NULL)
 304                new = &noop_qdisc;
 305
 306        sch_tree_lock(sch);
 307        *old = q->queues[band];
 308        q->queues[band] = new;
 309        qdisc_tree_decrease_qlen(*old, (*old)->q.qlen);
 310        qdisc_reset(*old);
 311        sch_tree_unlock(sch);
 312
 313        return 0;
 314}
 315
 316static struct Qdisc *
 317multiq_leaf(struct Qdisc *sch, unsigned long arg)
 318{
 319        struct multiq_sched_data *q = qdisc_priv(sch);
 320        unsigned long band = arg - 1;
 321
 322        return q->queues[band];
 323}
 324
 325static unsigned long multiq_get(struct Qdisc *sch, u32 classid)
 326{
 327        struct multiq_sched_data *q = qdisc_priv(sch);
 328        unsigned long band = TC_H_MIN(classid);
 329
 330        if (band - 1 >= q->bands)
 331                return 0;
 332        return band;
 333}
 334
 335static unsigned long multiq_bind(struct Qdisc *sch, unsigned long parent,
 336                                 u32 classid)
 337{
 338        return multiq_get(sch, classid);
 339}
 340
 341
 342static void multiq_put(struct Qdisc *q, unsigned long cl)
 343{
 344}
 345
 346static int multiq_dump_class(struct Qdisc *sch, unsigned long cl,
 347                             struct sk_buff *skb, struct tcmsg *tcm)
 348{
 349        struct multiq_sched_data *q = qdisc_priv(sch);
 350
 351        tcm->tcm_handle |= TC_H_MIN(cl);
 352        tcm->tcm_info = q->queues[cl - 1]->handle;
 353        return 0;
 354}
 355
 356static int multiq_dump_class_stats(struct Qdisc *sch, unsigned long cl,
 357                                 struct gnet_dump *d)
 358{
 359        struct multiq_sched_data *q = qdisc_priv(sch);
 360        struct Qdisc *cl_q;
 361
 362        cl_q = q->queues[cl - 1];
 363        cl_q->qstats.qlen = cl_q->q.qlen;
 364        if (gnet_stats_copy_basic(d, &cl_q->bstats) < 0 ||
 365            gnet_stats_copy_queue(d, &cl_q->qstats) < 0)
 366                return -1;
 367
 368        return 0;
 369}
 370
 371static void multiq_walk(struct Qdisc *sch, struct qdisc_walker *arg)
 372{
 373        struct multiq_sched_data *q = qdisc_priv(sch);
 374        int band;
 375
 376        if (arg->stop)
 377                return;
 378
 379        for (band = 0; band < q->bands; band++) {
 380                if (arg->count < arg->skip) {
 381                        arg->count++;
 382                        continue;
 383                }
 384                if (arg->fn(sch, band + 1, arg) < 0) {
 385                        arg->stop = 1;
 386                        break;
 387                }
 388                arg->count++;
 389        }
 390}
 391
 392static struct tcf_proto **multiq_find_tcf(struct Qdisc *sch, unsigned long cl)
 393{
 394        struct multiq_sched_data *q = qdisc_priv(sch);
 395
 396        if (cl)
 397                return NULL;
 398        return &q->filter_list;
 399}
 400
 401static const struct Qdisc_class_ops multiq_class_ops = {
 402        .graft          =       multiq_graft,
 403        .leaf           =       multiq_leaf,
 404        .get            =       multiq_get,
 405        .put            =       multiq_put,
 406        .walk           =       multiq_walk,
 407        .tcf_chain      =       multiq_find_tcf,
 408        .bind_tcf       =       multiq_bind,
 409        .unbind_tcf     =       multiq_put,
 410        .dump           =       multiq_dump_class,
 411        .dump_stats     =       multiq_dump_class_stats,
 412};
 413
 414static struct Qdisc_ops multiq_qdisc_ops __read_mostly = {
 415        .next           =       NULL,
 416        .cl_ops         =       &multiq_class_ops,
 417        .id             =       "multiq",
 418        .priv_size      =       sizeof(struct multiq_sched_data),
 419        .enqueue        =       multiq_enqueue,
 420        .dequeue        =       multiq_dequeue,
 421        .peek           =       multiq_peek,
 422        .drop           =       multiq_drop,
 423        .init           =       multiq_init,
 424        .reset          =       multiq_reset,
 425        .destroy        =       multiq_destroy,
 426        .change         =       multiq_tune,
 427        .dump           =       multiq_dump,
 428        .owner          =       THIS_MODULE,
 429};
 430
 431static int __init multiq_module_init(void)
 432{
 433        return register_qdisc(&multiq_qdisc_ops);
 434}
 435
 436static void __exit multiq_module_exit(void)
 437{
 438        unregister_qdisc(&multiq_qdisc_ops);
 439}
 440
 441module_init(multiq_module_init)
 442module_exit(multiq_module_exit)
 443
 444MODULE_LICENSE("GPL");
 445
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.