Merge branch 'drm-patches' of git://git.kernel.org/pub/scm/linux/kernel/git/airlied...
[linux-2.6] / net / sched / sch_fifo.c
1 /*
2  * net/sched/sch_fifo.c The simplest FIFO queue.
3  *
4  *              This program is free software; you can redistribute it and/or
5  *              modify it under the terms of the GNU General Public License
6  *              as published by the Free Software Foundation; either version
7  *              2 of the License, or (at your option) any later version.
8  *
9  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10  */
11
12 #include <linux/module.h>
13 #include <linux/types.h>
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/netdevice.h>
17 #include <linux/skbuff.h>
18 #include <net/pkt_sched.h>
19
20 /* 1 band FIFO pseudo-"scheduler" */
21
22 struct fifo_sched_data
23 {
24         u32 limit;
25 };
26
27 static int bfifo_enqueue(struct sk_buff *skb, struct Qdisc* sch)
28 {
29         struct fifo_sched_data *q = qdisc_priv(sch);
30
31         if (likely(sch->qstats.backlog + skb->len <= q->limit))
32                 return qdisc_enqueue_tail(skb, sch);
33
34         return qdisc_reshape_fail(skb, sch);
35 }
36
37 static int pfifo_enqueue(struct sk_buff *skb, struct Qdisc* sch)
38 {
39         struct fifo_sched_data *q = qdisc_priv(sch);
40
41         if (likely(skb_queue_len(&sch->q) < q->limit))
42                 return qdisc_enqueue_tail(skb, sch);
43
44         return qdisc_reshape_fail(skb, sch);
45 }
46
47 static int fifo_init(struct Qdisc *sch, struct rtattr *opt)
48 {
49         struct fifo_sched_data *q = qdisc_priv(sch);
50
51         if (opt == NULL) {
52                 u32 limit = sch->dev->tx_queue_len ? : 1;
53
54                 if (sch->ops == &bfifo_qdisc_ops)
55                         limit *= sch->dev->mtu;
56
57                 q->limit = limit;
58         } else {
59                 struct tc_fifo_qopt *ctl = RTA_DATA(opt);
60
61                 if (RTA_PAYLOAD(opt) < sizeof(*ctl))
62                         return -EINVAL;
63
64                 q->limit = ctl->limit;
65         }
66
67         return 0;
68 }
69
70 static int fifo_dump(struct Qdisc *sch, struct sk_buff *skb)
71 {
72         struct fifo_sched_data *q = qdisc_priv(sch);
73         struct tc_fifo_qopt opt = { .limit = q->limit };
74
75         RTA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
76         return skb->len;
77
78 rtattr_failure:
79         return -1;
80 }
81
82 struct Qdisc_ops pfifo_qdisc_ops = {
83         .id             =       "pfifo",
84         .priv_size      =       sizeof(struct fifo_sched_data),
85         .enqueue        =       pfifo_enqueue,
86         .dequeue        =       qdisc_dequeue_head,
87         .requeue        =       qdisc_requeue,
88         .drop           =       qdisc_queue_drop,
89         .init           =       fifo_init,
90         .reset          =       qdisc_reset_queue,
91         .change         =       fifo_init,
92         .dump           =       fifo_dump,
93         .owner          =       THIS_MODULE,
94 };
95
96 struct Qdisc_ops bfifo_qdisc_ops = {
97         .id             =       "bfifo",
98         .priv_size      =       sizeof(struct fifo_sched_data),
99         .enqueue        =       bfifo_enqueue,
100         .dequeue        =       qdisc_dequeue_head,
101         .requeue        =       qdisc_requeue,
102         .drop           =       qdisc_queue_drop,
103         .init           =       fifo_init,
104         .reset          =       qdisc_reset_queue,
105         .change         =       fifo_init,
106         .dump           =       fifo_dump,
107         .owner          =       THIS_MODULE,
108 };
109
110 EXPORT_SYMBOL(bfifo_qdisc_ops);
111 EXPORT_SYMBOL(pfifo_qdisc_ops);