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->bstats.bytes += qdisc_pkt_len(skb);
  87                sch->bstats.packets++;
  88                sch->q.qlen++;
  89                return NET_XMIT_SUCCESS;
  90        }
  91        if (net_xmit_drop_count(ret))
  92                sch->qstats.drops++;
  93        return ret;
  94}
  95
  96static struct sk_buff *multiq_dequeue(struct Qdisc *sch)
  97{
  98        struct multiq_sched_data *q = qdisc_priv(sch);
  99        struct Qdisc *qdisc;
 100        struct sk_buff *skb;
 101        int band;
 102
 103        for (band = 0; band < q->bands; band++) {
 104                /* cycle through bands to ensure fairness */
 105                q->curband++;
 106                if (q->curband >= q->bands)
 107                        q->curband = 0;
 108
 109                /* Check that target subqueue is available before
 110                 * pulling an skb to avoid head-of-line blocking.
 111                 */
 112                if (!__netif_subqueue_stopped(qdisc_dev(sch), q->curband)) {
 113                        qdisc = q->queues[q->curband];
 114                        skb = qdisc->dequeue(qdisc);
 115                        if (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_subqueue_stopped(qdisc_dev(sch), curband)) {
 143                        qdisc = q->queues[curband];
 144                        skb = qdisc->ops->peek(qdisc);
 145                        if (skb)
 146                                return skb;
 147                }
 148        }
 149        return NULL;
 150
 151}
 152
 153static unsigned int multiq_drop(struct Qdisc *sch)
 154{
 155        struct multiq_sched_data *q = qdisc_priv(sch);
 156        int band;
 157        unsigned int len;
 158        struct Qdisc *qdisc;
 159
 160        for (band = q->bands-1; band >= 0; band--) {
 161                qdisc = q->queues[band];
 162                if (qdisc->ops->drop) {
 163                        len = qdisc->ops->drop(qdisc);
 164                        if (len != 0) {
 165                                sch->q.qlen--;
 166                                return len;
 167                        }
 168                }
 169        }
 170        return 0;
 171}
 172
 173
 174static void
 175multiq_reset(struct Qdisc *sch)
 176{
 177        u16 band;
 178        struct multiq_sched_data *q = qdisc_priv(sch);
 179
 180        for (band = 0; band < q->bands; band++)
 181                qdisc_reset(q->queues[band]);
 182        sch->q.qlen = 0;
 183        q->curband = 0;
 184}
 185
 186static void
 187multiq_destroy(struct Qdisc *sch)
 188{
 189        int band;
 190        struct multiq_sched_data *q = qdisc_priv(sch);
 191
 192        tcf_destroy_chain(&q->filter_list);
 193        for (band = 0; band < q->bands; band++)
 194                qdisc_destroy(q->queues[band]);
 195
 196        kfree(q->queues);
 197}
 198
 199static int multiq_tune(struct Qdisc *sch, struct nlattr *opt)
 200{
 201        struct multiq_sched_data *q = qdisc_priv(sch);
 202        struct tc_multiq_qopt *qopt;
 203        int i;
 204
 205        if (!netif_is_multiqueue(qdisc_dev(sch)))
 206                return -EOPNOTSUPP;
 207        if (nla_len(opt) < sizeof(*qopt))
 208                return -EINVAL;
 209
 210        qopt = nla_data(opt);
 211
 212        qopt->bands = qdisc_dev(sch)->real_num_tx_queues;
 213
 214        sch_tree_lock(sch);
 215        q->bands = qopt->bands;
 216        for (i = q->bands; i < q->max_bands; i++) {
 217                if (q->queues[i] != &noop_qdisc) {
 218                        struct Qdisc *child = q->queues[i];
 219                        q->queues[i] = &noop_qdisc;
 220                        qdisc_tree_decrease_qlen(child, child->q.qlen);
 221                        qdisc_destroy(child);
 222                }
 223        }
 224
 225        sch_tree_unlock(sch);
 226
 227        for (i = 0; i < q->bands; i++) {
 228                if (q->queues[i] == &noop_qdisc) {
 229                        struct Qdisc *child, *old;
 230                        child = qdisc_create_dflt(sch->dev_queue,
 231                                                  &pfifo_qdisc_ops,
 232                                                  TC_H_MAKE(sch->handle,
 233                                                            i + 1));
 234                        if (child) {
 235                                sch_tree_lock(sch);
 236                                old = q->queues[i];
 237                                q->queues[i] = child;
 238
 239                                if (old != &noop_qdisc) {
 240                                        qdisc_tree_decrease_qlen(old,
 241                                                                 old->q.qlen);
 242                                        qdisc_destroy(old);
 243                                }
 244                                sch_tree_unlock(sch);
 245                        }
 246                }
 247        }
 248        return 0;
 249}
 250
 251static int multiq_init(struct Qdisc *sch, struct nlattr *opt)
 252{
 253        struct multiq_sched_data *q = qdisc_priv(sch);
 254        int i, err;
 255
 256        q->queues = NULL;
 257
 258        if (opt == NULL)
 259                return -EINVAL;
 260
 261        q->max_bands = qdisc_dev(sch)->num_tx_queues;
 262
 263        q->queues = kcalloc(q->max_bands, sizeof(struct Qdisc *), GFP_KERNEL);
 264        if (!q->queues)
 265                return -ENOBUFS;
 266        for (i = 0; i < q->max_bands; i++)
 267                q->queues[i] = &noop_qdisc;
 268
 269        err = multiq_tune(sch,opt);
 270
 271        if (err)
 272                kfree(q->queues);
 273
 274        return err;
 275}
 276
 277static int multiq_dump(struct Qdisc *sch, struct sk_buff *skb)
 278{
 279        struct multiq_sched_data *q = qdisc_priv(sch);
 280        unsigned char *b = skb_tail_pointer(skb);
 281        struct tc_multiq_qopt opt;
 282
 283        opt.bands = q->bands;
 284        opt.max_bands = q->max_bands;
 285
 286        NLA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
 287
 288        return skb->len;
 289
 290nla_put_failure:
 291        nlmsg_trim(skb, b);
 292        return -1;
 293}
 294
 295static int multiq_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
 296                      struct Qdisc **old)
 297{
 298        struct multiq_sched_data *q = qdisc_priv(sch);
 299        unsigned long band = arg - 1;
 300
 301        if (new == NULL)
 302                new = &noop_qdisc;
 303
 304        sch_tree_lock(sch);
 305        *old = q->queues[band];
 306        q->queues[band] = new;
 307        qdisc_tree_decrease_qlen(*old, (*old)->q.qlen);
 308        qdisc_reset(*old);
 309        sch_tree_unlock(sch);
 310
 311        return 0;
 312}
 313
 314static struct Qdisc *
 315multiq_leaf(struct Qdisc *sch, unsigned long arg)
 316{
 317        struct multiq_sched_data *q = qdisc_priv(sch);
 318        unsigned long band = arg - 1;
 319
 320        return q->queues[band];
 321}
 322
 323static unsigned long multiq_get(struct Qdisc *sch, u32 classid)
 324{
 325        struct multiq_sched_data *q = qdisc_priv(sch);
 326        unsigned long band = TC_H_MIN(classid);
 327
 328        if (band - 1 >= q->bands)
 329                return 0;
 330        return band;
 331}
 332
 333static unsigned long multiq_bind(struct Qdisc *sch, unsigned long parent,
 334                                 u32 classid)
 335{
 336        return multiq_get(sch, classid);
 337}
 338
 339
 340static void multiq_put(struct Qdisc *q, unsigned long cl)
 341{
 342}
 343
 344static int multiq_dump_class(struct Qdisc *sch, unsigned long cl,
 345                             struct sk_buff *skb, struct tcmsg *tcm)
 346{
 347        struct multiq_sched_data *q = qdisc_priv(sch);
 348
 349        tcm->tcm_handle |= TC_H_MIN(cl);
 350        tcm->tcm_info = q->queues[cl-1]->handle;
 351        return 0;
 352}
 353
 354static int multiq_dump_class_stats(struct Qdisc *sch, unsigned long cl,
 355                                 struct gnet_dump *d)
 356{
 357        struct multiq_sched_data *q = qdisc_priv(sch);
 358        struct Qdisc *cl_q;
 359
 360        cl_q = q->queues[cl - 1];
 361        cl_q->qstats.qlen = cl_q->q.qlen;
 362        if (gnet_stats_copy_basic(d, &cl_q->bstats) < 0 ||
 363            gnet_stats_copy_queue(d, &cl_q->qstats) < 0)
 364                return -1;
 365
 366        return 0;
 367}
 368
 369static void multiq_walk(struct Qdisc *sch, struct qdisc_walker *arg)
 370{
 371        struct multiq_sched_data *q = qdisc_priv(sch);
 372        int band;
 373
 374        if (arg->stop)
 375                return;
 376
 377        for (band = 0; band < q->bands; band++) {
 378                if (arg->count < arg->skip) {
 379                        arg->count++;
 380                        continue;
 381                }
 382                if (arg->fn(sch, band+1, arg) < 0) {
 383                        arg->stop = 1;
 384                        break;
 385                }
 386                arg->count++;
 387        }
 388}
 389
 390static struct tcf_proto **multiq_find_tcf(struct Qdisc *sch, unsigned long cl)
 391{
 392        struct multiq_sched_data *q = qdisc_priv(sch);
 393
 394        if (cl)
 395                return NULL;
 396        return &q->filter_list;
 397}
 398
 399static const struct Qdisc_class_ops multiq_class_ops = {
 400        .graft          =       multiq_graft,
 401        .leaf           =       multiq_leaf,
 402        .get            =       multiq_get,
 403        .put            =       multiq_put,
 404        .walk           =       multiq_walk,
 405        .tcf_chain      =       multiq_find_tcf,
 406        .bind_tcf       =       multiq_bind,
 407        .unbind_tcf     =       multiq_put,
 408        .dump           =       multiq_dump_class,
 409        .dump_stats     =       multiq_dump_class_stats,
 410};
 411
 412static struct Qdisc_ops multiq_qdisc_ops __read_mostly = {
 413        .next           =       NULL,
 414        .cl_ops         =       &multiq_class_ops,
 415        .id             =       "multiq",
 416        .priv_size      =       sizeof(struct multiq_sched_data),
 417        .enqueue        =       multiq_enqueue,
 418        .dequeue        =       multiq_dequeue,
 419        .peek           =       multiq_peek,
 420        .drop           =       multiq_drop,
 421        .init           =       multiq_init,
 422        .reset          =       multiq_reset,
 423        .destroy        =       multiq_destroy,
 424        .change         =       multiq_tune,
 425        .dump           =       multiq_dump,
 426        .owner          =       THIS_MODULE,
 427};
 428
 429static int __init multiq_module_init(void)
 430{
 431        return register_qdisc(&multiq_qdisc_ops);
 432}
 433
 434static void __exit multiq_module_exit(void)
 435{
 436        unregister_qdisc(&multiq_qdisc_ops);
 437}
 438
 439module_init(multiq_module_init)
 440module_exit(multiq_module_exit)
 441
 442MODULE_LICENSE("GPL");
 443