ipv4: tcp: set unicast_sock uc_ttl to -1
[linux-3.10.git] / net / sched / sch_multiq.c
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
31 struct 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
40 static struct Qdisc *
41 multiq_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
67 static int
68 multiq_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
94 static 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
125 static 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
154 static 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
175 static void
176 multiq_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
187 static void
188 multiq_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
200 static 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
252 static 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
278 static 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
292 nla_put_failure:
293         nlmsg_trim(skb, b);
294         return -1;
295 }
296
297 static 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
316 static struct Qdisc *
317 multiq_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
325 static 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
335 static unsigned long multiq_bind(struct Qdisc *sch, unsigned long parent,
336                                  u32 classid)
337 {
338         return multiq_get(sch, classid);
339 }
340
341
342 static void multiq_put(struct Qdisc *q, unsigned long cl)
343 {
344 }
345
346 static 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
356 static 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
371 static 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
392 static 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
401 static 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
414 static 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
431 static int __init multiq_module_init(void)
432 {
433         return register_qdisc(&multiq_qdisc_ops);
434 }
435
436 static void __exit multiq_module_exit(void)
437 {
438         unregister_qdisc(&multiq_qdisc_ops);
439 }
440
441 module_init(multiq_module_init)
442 module_exit(multiq_module_exit)
443
444 MODULE_LICENSE("GPL");