ipv4: tcp: set unicast_sock uc_ttl to -1
[linux-3.10.git] / net / sched / sch_mq.c
1 /*
2  * net/sched/sch_mq.c           Classful multiqueue dummy scheduler
3  *
4  * Copyright (c) 2009 Patrick McHardy <kaber@trash.net>
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * version 2 as published by the Free Software Foundation.
9  */
10
11 #include <linux/types.h>
12 #include <linux/slab.h>
13 #include <linux/kernel.h>
14 #include <linux/export.h>
15 #include <linux/string.h>
16 #include <linux/errno.h>
17 #include <linux/skbuff.h>
18 #include <net/netlink.h>
19 #include <net/pkt_sched.h>
20
21 struct mq_sched {
22         struct Qdisc            **qdiscs;
23 };
24
25 static void mq_destroy(struct Qdisc *sch)
26 {
27         struct net_device *dev = qdisc_dev(sch);
28         struct mq_sched *priv = qdisc_priv(sch);
29         unsigned int ntx;
30
31         if (!priv->qdiscs)
32                 return;
33         for (ntx = 0; ntx < dev->num_tx_queues && priv->qdiscs[ntx]; ntx++)
34                 qdisc_destroy(priv->qdiscs[ntx]);
35         kfree(priv->qdiscs);
36 }
37
38 static int mq_init(struct Qdisc *sch, struct nlattr *opt)
39 {
40         struct net_device *dev = qdisc_dev(sch);
41         struct mq_sched *priv = qdisc_priv(sch);
42         struct netdev_queue *dev_queue;
43         struct Qdisc *qdisc;
44         unsigned int ntx;
45
46         if (sch->parent != TC_H_ROOT)
47                 return -EOPNOTSUPP;
48
49         if (!netif_is_multiqueue(dev))
50                 return -EOPNOTSUPP;
51
52         /* pre-allocate qdiscs, attachment can't fail */
53         priv->qdiscs = kcalloc(dev->num_tx_queues, sizeof(priv->qdiscs[0]),
54                                GFP_KERNEL);
55         if (priv->qdiscs == NULL)
56                 return -ENOMEM;
57
58         for (ntx = 0; ntx < dev->num_tx_queues; ntx++) {
59                 dev_queue = netdev_get_tx_queue(dev, ntx);
60                 qdisc = qdisc_create_dflt(dev_queue, &pfifo_fast_ops,
61                                           TC_H_MAKE(TC_H_MAJ(sch->handle),
62                                                     TC_H_MIN(ntx + 1)));
63                 if (qdisc == NULL)
64                         goto err;
65                 priv->qdiscs[ntx] = qdisc;
66         }
67
68         sch->flags |= TCQ_F_MQROOT;
69         return 0;
70
71 err:
72         mq_destroy(sch);
73         return -ENOMEM;
74 }
75
76 static void mq_attach(struct Qdisc *sch)
77 {
78         struct net_device *dev = qdisc_dev(sch);
79         struct mq_sched *priv = qdisc_priv(sch);
80         struct Qdisc *qdisc;
81         unsigned int ntx;
82
83         for (ntx = 0; ntx < dev->num_tx_queues; ntx++) {
84                 qdisc = priv->qdiscs[ntx];
85                 qdisc = dev_graft_qdisc(qdisc->dev_queue, qdisc);
86                 if (qdisc)
87                         qdisc_destroy(qdisc);
88         }
89         kfree(priv->qdiscs);
90         priv->qdiscs = NULL;
91 }
92
93 static int mq_dump(struct Qdisc *sch, struct sk_buff *skb)
94 {
95         struct net_device *dev = qdisc_dev(sch);
96         struct Qdisc *qdisc;
97         unsigned int ntx;
98
99         sch->q.qlen = 0;
100         memset(&sch->bstats, 0, sizeof(sch->bstats));
101         memset(&sch->qstats, 0, sizeof(sch->qstats));
102
103         for (ntx = 0; ntx < dev->num_tx_queues; ntx++) {
104                 qdisc = netdev_get_tx_queue(dev, ntx)->qdisc_sleeping;
105                 spin_lock_bh(qdisc_lock(qdisc));
106                 sch->q.qlen             += qdisc->q.qlen;
107                 sch->bstats.bytes       += qdisc->bstats.bytes;
108                 sch->bstats.packets     += qdisc->bstats.packets;
109                 sch->qstats.qlen        += qdisc->qstats.qlen;
110                 sch->qstats.backlog     += qdisc->qstats.backlog;
111                 sch->qstats.drops       += qdisc->qstats.drops;
112                 sch->qstats.requeues    += qdisc->qstats.requeues;
113                 sch->qstats.overlimits  += qdisc->qstats.overlimits;
114                 spin_unlock_bh(qdisc_lock(qdisc));
115         }
116         return 0;
117 }
118
119 static struct netdev_queue *mq_queue_get(struct Qdisc *sch, unsigned long cl)
120 {
121         struct net_device *dev = qdisc_dev(sch);
122         unsigned long ntx = cl - 1;
123
124         if (ntx >= dev->num_tx_queues)
125                 return NULL;
126         return netdev_get_tx_queue(dev, ntx);
127 }
128
129 static struct netdev_queue *mq_select_queue(struct Qdisc *sch,
130                                             struct tcmsg *tcm)
131 {
132         unsigned int ntx = TC_H_MIN(tcm->tcm_parent);
133         struct netdev_queue *dev_queue = mq_queue_get(sch, ntx);
134
135         if (!dev_queue) {
136                 struct net_device *dev = qdisc_dev(sch);
137
138                 return netdev_get_tx_queue(dev, 0);
139         }
140         return dev_queue;
141 }
142
143 static int mq_graft(struct Qdisc *sch, unsigned long cl, struct Qdisc *new,
144                     struct Qdisc **old)
145 {
146         struct netdev_queue *dev_queue = mq_queue_get(sch, cl);
147         struct net_device *dev = qdisc_dev(sch);
148
149         if (dev->flags & IFF_UP)
150                 dev_deactivate(dev);
151
152         *old = dev_graft_qdisc(dev_queue, new);
153
154         if (dev->flags & IFF_UP)
155                 dev_activate(dev);
156         return 0;
157 }
158
159 static struct Qdisc *mq_leaf(struct Qdisc *sch, unsigned long cl)
160 {
161         struct netdev_queue *dev_queue = mq_queue_get(sch, cl);
162
163         return dev_queue->qdisc_sleeping;
164 }
165
166 static unsigned long mq_get(struct Qdisc *sch, u32 classid)
167 {
168         unsigned int ntx = TC_H_MIN(classid);
169
170         if (!mq_queue_get(sch, ntx))
171                 return 0;
172         return ntx;
173 }
174
175 static void mq_put(struct Qdisc *sch, unsigned long cl)
176 {
177 }
178
179 static int mq_dump_class(struct Qdisc *sch, unsigned long cl,
180                          struct sk_buff *skb, struct tcmsg *tcm)
181 {
182         struct netdev_queue *dev_queue = mq_queue_get(sch, cl);
183
184         tcm->tcm_parent = TC_H_ROOT;
185         tcm->tcm_handle |= TC_H_MIN(cl);
186         tcm->tcm_info = dev_queue->qdisc_sleeping->handle;
187         return 0;
188 }
189
190 static int mq_dump_class_stats(struct Qdisc *sch, unsigned long cl,
191                                struct gnet_dump *d)
192 {
193         struct netdev_queue *dev_queue = mq_queue_get(sch, cl);
194
195         sch = dev_queue->qdisc_sleeping;
196         sch->qstats.qlen = sch->q.qlen;
197         if (gnet_stats_copy_basic(d, &sch->bstats) < 0 ||
198             gnet_stats_copy_queue(d, &sch->qstats) < 0)
199                 return -1;
200         return 0;
201 }
202
203 static void mq_walk(struct Qdisc *sch, struct qdisc_walker *arg)
204 {
205         struct net_device *dev = qdisc_dev(sch);
206         unsigned int ntx;
207
208         if (arg->stop)
209                 return;
210
211         arg->count = arg->skip;
212         for (ntx = arg->skip; ntx < dev->num_tx_queues; ntx++) {
213                 if (arg->fn(sch, ntx + 1, arg) < 0) {
214                         arg->stop = 1;
215                         break;
216                 }
217                 arg->count++;
218         }
219 }
220
221 static const struct Qdisc_class_ops mq_class_ops = {
222         .select_queue   = mq_select_queue,
223         .graft          = mq_graft,
224         .leaf           = mq_leaf,
225         .get            = mq_get,
226         .put            = mq_put,
227         .walk           = mq_walk,
228         .dump           = mq_dump_class,
229         .dump_stats     = mq_dump_class_stats,
230 };
231
232 struct Qdisc_ops mq_qdisc_ops __read_mostly = {
233         .cl_ops         = &mq_class_ops,
234         .id             = "mq",
235         .priv_size      = sizeof(struct mq_sched),
236         .init           = mq_init,
237         .destroy        = mq_destroy,
238         .attach         = mq_attach,
239         .dump           = mq_dump,
240         .owner          = THIS_MODULE,
241 };