2 * net/sched/sch_fifo.c The simplest FIFO queue.
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.
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/types.h>
15 #include <linux/kernel.h>
16 #include <linux/errno.h>
17 #include <linux/skbuff.h>
18 #include <net/pkt_sched.h>
20 /* 1 band FIFO pseudo-"scheduler" */
22 struct fifo_sched_data
{
26 static int bfifo_enqueue(struct sk_buff
*skb
, struct Qdisc
*sch
)
28 struct fifo_sched_data
*q
= qdisc_priv(sch
);
30 if (likely(sch
->qstats
.backlog
+ qdisc_pkt_len(skb
) <= q
->limit
))
31 return qdisc_enqueue_tail(skb
, sch
);
33 return qdisc_reshape_fail(skb
, sch
);
36 static int pfifo_enqueue(struct sk_buff
*skb
, struct Qdisc
*sch
)
38 struct fifo_sched_data
*q
= qdisc_priv(sch
);
40 if (likely(skb_queue_len(&sch
->q
) < q
->limit
))
41 return qdisc_enqueue_tail(skb
, sch
);
43 return qdisc_reshape_fail(skb
, sch
);
46 static int pfifo_tail_enqueue(struct sk_buff
*skb
, struct Qdisc
*sch
)
48 struct sk_buff
*skb_head
;
49 struct fifo_sched_data
*q
= qdisc_priv(sch
);
51 if (likely(skb_queue_len(&sch
->q
) < q
->limit
))
52 return qdisc_enqueue_tail(skb
, sch
);
54 /* queue full, remove one skb to fulfill the limit */
55 skb_head
= qdisc_dequeue_head(sch
);
59 qdisc_enqueue_tail(skb
, sch
);
64 static int fifo_init(struct Qdisc
*sch
, struct nlattr
*opt
)
66 struct fifo_sched_data
*q
= qdisc_priv(sch
);
69 u32 limit
= qdisc_dev(sch
)->tx_queue_len
? : 1;
71 if (sch
->ops
== &bfifo_qdisc_ops
)
72 limit
*= psched_mtu(qdisc_dev(sch
));
76 struct tc_fifo_qopt
*ctl
= nla_data(opt
);
78 if (nla_len(opt
) < sizeof(*ctl
))
81 q
->limit
= ctl
->limit
;
87 static int fifo_dump(struct Qdisc
*sch
, struct sk_buff
*skb
)
89 struct fifo_sched_data
*q
= qdisc_priv(sch
);
90 struct tc_fifo_qopt opt
= { .limit
= q
->limit
};
92 NLA_PUT(skb
, TCA_OPTIONS
, sizeof(opt
), &opt
);
99 struct Qdisc_ops pfifo_qdisc_ops __read_mostly
= {
101 .priv_size
= sizeof(struct fifo_sched_data
),
102 .enqueue
= pfifo_enqueue
,
103 .dequeue
= qdisc_dequeue_head
,
104 .peek
= qdisc_peek_head
,
105 .drop
= qdisc_queue_drop
,
107 .reset
= qdisc_reset_queue
,
110 .owner
= THIS_MODULE
,
112 EXPORT_SYMBOL(pfifo_qdisc_ops
);
114 struct Qdisc_ops bfifo_qdisc_ops __read_mostly
= {
116 .priv_size
= sizeof(struct fifo_sched_data
),
117 .enqueue
= bfifo_enqueue
,
118 .dequeue
= qdisc_dequeue_head
,
119 .peek
= qdisc_peek_head
,
120 .drop
= qdisc_queue_drop
,
122 .reset
= qdisc_reset_queue
,
125 .owner
= THIS_MODULE
,
127 EXPORT_SYMBOL(bfifo_qdisc_ops
);
129 struct Qdisc_ops pfifo_head_drop_qdisc_ops __read_mostly
= {
130 .id
= "pfifo_head_drop",
131 .priv_size
= sizeof(struct fifo_sched_data
),
132 .enqueue
= pfifo_tail_enqueue
,
133 .dequeue
= qdisc_dequeue_head
,
134 .peek
= qdisc_peek_head
,
135 .drop
= qdisc_queue_drop_head
,
137 .reset
= qdisc_reset_queue
,
140 .owner
= THIS_MODULE
,
143 /* Pass size change message down to embedded FIFO */
144 int fifo_set_limit(struct Qdisc
*q
, unsigned int limit
)
149 /* Hack to avoid sending change message to non-FIFO */
150 if (strncmp(q
->ops
->id
+ 1, "fifo", 4) != 0)
153 nla
= kmalloc(nla_attr_size(sizeof(struct tc_fifo_qopt
)), GFP_KERNEL
);
155 nla
->nla_type
= RTM_NEWQDISC
;
156 nla
->nla_len
= nla_attr_size(sizeof(struct tc_fifo_qopt
));
157 ((struct tc_fifo_qopt
*)nla_data(nla
))->limit
= limit
;
159 ret
= q
->ops
->change(q
, nla
);
164 EXPORT_SYMBOL(fifo_set_limit
);
166 struct Qdisc
*fifo_create_dflt(struct Qdisc
*sch
, struct Qdisc_ops
*ops
,
172 q
= qdisc_create_dflt(sch
->dev_queue
, ops
, TC_H_MAKE(sch
->handle
, 1));
174 err
= fifo_set_limit(q
, limit
);
181 return q
? : ERR_PTR(err
);
183 EXPORT_SYMBOL(fifo_create_dflt
);