1 #ifndef __NET_SCHED_GENERIC_H
2 #define __NET_SCHED_GENERIC_H
4 #include <linux/netdevice.h>
5 #include <linux/types.h>
6 #include <linux/rcupdate.h>
7 #include <linux/module.h>
8 #include <linux/pkt_sched.h>
9 #include <linux/pkt_cls.h>
10 #include <net/gen_stats.h>
11 #include <net/rtnetlink.h>
18 struct qdisc_rate_table
20 struct tc_ratespec rate
;
22 struct qdisc_rate_table
*next
;
28 __QDISC_STATE_RUNNING
,
30 __QDISC_STATE_DEACTIVATED
,
33 struct qdisc_size_table
{
34 struct list_head list
;
35 struct tc_sizespec szopts
;
42 int (*enqueue
)(struct sk_buff
*skb
, struct Qdisc
*dev
);
43 struct sk_buff
* (*dequeue
)(struct Qdisc
*dev
);
45 #define TCQ_F_BUILTIN 1
46 #define TCQ_F_THROTTLED 2
47 #define TCQ_F_INGRESS 4
49 struct Qdisc_ops
*ops
;
50 struct qdisc_size_table
*stab
;
55 struct sk_buff
*gso_skb
;
56 struct sk_buff_head q
;
57 struct netdev_queue
*dev_queue
;
58 struct Qdisc
*next_sched
;
59 struct list_head list
;
61 struct gnet_stats_basic bstats
;
62 struct gnet_stats_queue qstats
;
63 struct gnet_stats_rate_est rate_est
;
64 int (*reshape_fail
)(struct sk_buff
*skb
,
69 /* This field is deprecated, but it is still used by CBQ
70 * and it will live until better solution will be invented.
72 struct Qdisc
*__parent
;
75 struct Qdisc_class_ops
77 /* Child qdisc manipulation */
78 int (*graft
)(struct Qdisc
*, unsigned long cl
,
79 struct Qdisc
*, struct Qdisc
**);
80 struct Qdisc
* (*leaf
)(struct Qdisc
*, unsigned long cl
);
81 void (*qlen_notify
)(struct Qdisc
*, unsigned long);
83 /* Class manipulation routines */
84 unsigned long (*get
)(struct Qdisc
*, u32 classid
);
85 void (*put
)(struct Qdisc
*, unsigned long);
86 int (*change
)(struct Qdisc
*, u32
, u32
,
87 struct nlattr
**, unsigned long *);
88 int (*delete)(struct Qdisc
*, unsigned long);
89 void (*walk
)(struct Qdisc
*, struct qdisc_walker
* arg
);
91 /* Filter manipulation */
92 struct tcf_proto
** (*tcf_chain
)(struct Qdisc
*, unsigned long);
93 unsigned long (*bind_tcf
)(struct Qdisc
*, unsigned long,
95 void (*unbind_tcf
)(struct Qdisc
*, unsigned long);
97 /* rtnetlink specific */
98 int (*dump
)(struct Qdisc
*, unsigned long,
99 struct sk_buff
*skb
, struct tcmsg
*);
100 int (*dump_stats
)(struct Qdisc
*, unsigned long,
106 struct Qdisc_ops
*next
;
107 const struct Qdisc_class_ops
*cl_ops
;
111 int (*enqueue
)(struct sk_buff
*, struct Qdisc
*);
112 struct sk_buff
* (*dequeue
)(struct Qdisc
*);
113 int (*requeue
)(struct sk_buff
*, struct Qdisc
*);
114 unsigned int (*drop
)(struct Qdisc
*);
116 int (*init
)(struct Qdisc
*, struct nlattr
*arg
);
117 void (*reset
)(struct Qdisc
*);
118 void (*destroy
)(struct Qdisc
*);
119 int (*change
)(struct Qdisc
*, struct nlattr
*arg
);
121 int (*dump
)(struct Qdisc
*, struct sk_buff
*);
122 int (*dump_stats
)(struct Qdisc
*, struct gnet_dump
*);
124 struct module
*owner
;
136 struct tcf_proto_ops
*next
;
139 int (*classify
)(struct sk_buff
*, struct tcf_proto
*,
140 struct tcf_result
*);
141 int (*init
)(struct tcf_proto
*);
142 void (*destroy
)(struct tcf_proto
*);
144 unsigned long (*get
)(struct tcf_proto
*, u32 handle
);
145 void (*put
)(struct tcf_proto
*, unsigned long);
146 int (*change
)(struct tcf_proto
*, unsigned long,
147 u32 handle
, struct nlattr
**,
149 int (*delete)(struct tcf_proto
*, unsigned long);
150 void (*walk
)(struct tcf_proto
*, struct tcf_walker
*arg
);
152 /* rtnetlink specific */
153 int (*dump
)(struct tcf_proto
*, unsigned long,
154 struct sk_buff
*skb
, struct tcmsg
*);
156 struct module
*owner
;
161 /* Fast access part */
162 struct tcf_proto
*next
;
164 int (*classify
)(struct sk_buff
*, struct tcf_proto
*,
165 struct tcf_result
*);
173 struct tcf_proto_ops
*ops
;
176 struct qdisc_skb_cb
{
177 unsigned int pkt_len
;
181 static inline struct qdisc_skb_cb
*qdisc_skb_cb(struct sk_buff
*skb
)
183 return (struct qdisc_skb_cb
*)skb
->cb
;
186 static inline spinlock_t
*qdisc_lock(struct Qdisc
*qdisc
)
188 return &qdisc
->q
.lock
;
191 static inline struct Qdisc
*qdisc_root(struct Qdisc
*qdisc
)
193 return qdisc
->dev_queue
->qdisc
;
196 static inline struct Qdisc
*qdisc_root_sleeping(struct Qdisc
*qdisc
)
198 return qdisc
->dev_queue
->qdisc_sleeping
;
201 /* The qdisc root lock is a mechanism by which to top level
202 * of a qdisc tree can be locked from any qdisc node in the
203 * forest. This allows changing the configuration of some
204 * aspect of the qdisc tree while blocking out asynchronous
205 * qdisc access in the packet processing paths.
207 * It is only legal to do this when the root will not change
208 * on us. Otherwise we'll potentially lock the wrong qdisc
209 * root. This is enforced by holding the RTNL semaphore, which
210 * all users of this lock accessor must do.
212 static inline spinlock_t
*qdisc_root_lock(struct Qdisc
*qdisc
)
214 struct Qdisc
*root
= qdisc_root(qdisc
);
217 return qdisc_lock(root
);
220 static inline struct net_device
*qdisc_dev(struct Qdisc
*qdisc
)
222 return qdisc
->dev_queue
->dev
;
225 static inline void sch_tree_lock(struct Qdisc
*q
)
227 spin_lock_bh(qdisc_root_lock(q
));
230 static inline void sch_tree_unlock(struct Qdisc
*q
)
232 spin_unlock_bh(qdisc_root_lock(q
));
235 #define tcf_tree_lock(tp) sch_tree_lock((tp)->q)
236 #define tcf_tree_unlock(tp) sch_tree_unlock((tp)->q)
238 extern struct Qdisc noop_qdisc
;
239 extern struct Qdisc_ops noop_qdisc_ops
;
241 struct Qdisc_class_common
244 struct hlist_node hnode
;
247 struct Qdisc_class_hash
249 struct hlist_head
*hash
;
250 unsigned int hashsize
;
251 unsigned int hashmask
;
252 unsigned int hashelems
;
255 static inline unsigned int qdisc_class_hash(u32 id
, u32 mask
)
262 static inline struct Qdisc_class_common
*
263 qdisc_class_find(struct Qdisc_class_hash
*hash
, u32 id
)
265 struct Qdisc_class_common
*cl
;
266 struct hlist_node
*n
;
269 h
= qdisc_class_hash(id
, hash
->hashmask
);
270 hlist_for_each_entry(cl
, n
, &hash
->hash
[h
], hnode
) {
271 if (cl
->classid
== id
)
277 extern int qdisc_class_hash_init(struct Qdisc_class_hash
*);
278 extern void qdisc_class_hash_insert(struct Qdisc_class_hash
*, struct Qdisc_class_common
*);
279 extern void qdisc_class_hash_remove(struct Qdisc_class_hash
*, struct Qdisc_class_common
*);
280 extern void qdisc_class_hash_grow(struct Qdisc
*, struct Qdisc_class_hash
*);
281 extern void qdisc_class_hash_destroy(struct Qdisc_class_hash
*);
283 extern void dev_init_scheduler(struct net_device
*dev
);
284 extern void dev_shutdown(struct net_device
*dev
);
285 extern void dev_activate(struct net_device
*dev
);
286 extern void dev_deactivate(struct net_device
*dev
);
287 extern void qdisc_reset(struct Qdisc
*qdisc
);
288 extern void qdisc_destroy(struct Qdisc
*qdisc
);
289 extern void qdisc_tree_decrease_qlen(struct Qdisc
*qdisc
, unsigned int n
);
290 extern struct Qdisc
*qdisc_alloc(struct netdev_queue
*dev_queue
,
291 struct Qdisc_ops
*ops
);
292 extern struct Qdisc
*qdisc_create_dflt(struct net_device
*dev
,
293 struct netdev_queue
*dev_queue
,
294 struct Qdisc_ops
*ops
, u32 parentid
);
295 extern void qdisc_calculate_pkt_len(struct sk_buff
*skb
,
296 struct qdisc_size_table
*stab
);
297 extern void tcf_destroy(struct tcf_proto
*tp
);
298 extern void tcf_destroy_chain(struct tcf_proto
**fl
);
300 /* Reset all TX qdiscs of a device. */
301 static inline void qdisc_reset_all_tx(struct net_device
*dev
)
304 for (i
= 0; i
< dev
->num_tx_queues
; i
++)
305 qdisc_reset(netdev_get_tx_queue(dev
, i
)->qdisc
);
308 /* Are all TX queues of the device empty? */
309 static inline bool qdisc_all_tx_empty(const struct net_device
*dev
)
312 for (i
= 0; i
< dev
->num_tx_queues
; i
++) {
313 struct netdev_queue
*txq
= netdev_get_tx_queue(dev
, i
);
314 const struct Qdisc
*q
= txq
->qdisc
;
322 /* Are any of the TX qdiscs changing? */
323 static inline bool qdisc_tx_changing(struct net_device
*dev
)
326 for (i
= 0; i
< dev
->num_tx_queues
; i
++) {
327 struct netdev_queue
*txq
= netdev_get_tx_queue(dev
, i
);
328 if (txq
->qdisc
!= txq
->qdisc_sleeping
)
334 /* Is the device using the noop qdisc on all queues? */
335 static inline bool qdisc_tx_is_noop(const struct net_device
*dev
)
338 for (i
= 0; i
< dev
->num_tx_queues
; i
++) {
339 struct netdev_queue
*txq
= netdev_get_tx_queue(dev
, i
);
340 if (txq
->qdisc
!= &noop_qdisc
)
346 static inline unsigned int qdisc_pkt_len(struct sk_buff
*skb
)
348 return qdisc_skb_cb(skb
)->pkt_len
;
351 /* additional qdisc xmit flags (NET_XMIT_MASK in linux/netdevice.h) */
352 enum net_xmit_qdisc_t
{
353 __NET_XMIT_STOLEN
= 0x00010000,
354 __NET_XMIT_BYPASS
= 0x00020000,
357 #ifdef CONFIG_NET_CLS_ACT
358 #define net_xmit_drop_count(e) ((e) & __NET_XMIT_STOLEN ? 0 : 1)
360 #define net_xmit_drop_count(e) (1)
363 static inline int qdisc_enqueue(struct sk_buff
*skb
, struct Qdisc
*sch
)
365 #ifdef CONFIG_NET_SCHED
367 qdisc_calculate_pkt_len(skb
, sch
->stab
);
369 return sch
->enqueue(skb
, sch
);
372 static inline int qdisc_enqueue_root(struct sk_buff
*skb
, struct Qdisc
*sch
)
374 qdisc_skb_cb(skb
)->pkt_len
= skb
->len
;
375 return qdisc_enqueue(skb
, sch
) & NET_XMIT_MASK
;
378 static inline int __qdisc_enqueue_tail(struct sk_buff
*skb
, struct Qdisc
*sch
,
379 struct sk_buff_head
*list
)
381 __skb_queue_tail(list
, skb
);
382 sch
->qstats
.backlog
+= qdisc_pkt_len(skb
);
383 sch
->bstats
.bytes
+= qdisc_pkt_len(skb
);
384 sch
->bstats
.packets
++;
386 return NET_XMIT_SUCCESS
;
389 static inline int qdisc_enqueue_tail(struct sk_buff
*skb
, struct Qdisc
*sch
)
391 return __qdisc_enqueue_tail(skb
, sch
, &sch
->q
);
394 static inline struct sk_buff
*__qdisc_dequeue_head(struct Qdisc
*sch
,
395 struct sk_buff_head
*list
)
397 struct sk_buff
*skb
= __skb_dequeue(list
);
399 if (likely(skb
!= NULL
))
400 sch
->qstats
.backlog
-= qdisc_pkt_len(skb
);
405 static inline struct sk_buff
*qdisc_dequeue_head(struct Qdisc
*sch
)
407 return __qdisc_dequeue_head(sch
, &sch
->q
);
410 static inline struct sk_buff
*__qdisc_dequeue_tail(struct Qdisc
*sch
,
411 struct sk_buff_head
*list
)
413 struct sk_buff
*skb
= __skb_dequeue_tail(list
);
415 if (likely(skb
!= NULL
))
416 sch
->qstats
.backlog
-= qdisc_pkt_len(skb
);
421 static inline struct sk_buff
*qdisc_dequeue_tail(struct Qdisc
*sch
)
423 return __qdisc_dequeue_tail(sch
, &sch
->q
);
426 static inline int __qdisc_requeue(struct sk_buff
*skb
, struct Qdisc
*sch
,
427 struct sk_buff_head
*list
)
429 __skb_queue_head(list
, skb
);
430 sch
->qstats
.backlog
+= qdisc_pkt_len(skb
);
431 sch
->qstats
.requeues
++;
433 return NET_XMIT_SUCCESS
;
436 static inline int qdisc_requeue(struct sk_buff
*skb
, struct Qdisc
*sch
)
438 return __qdisc_requeue(skb
, sch
, &sch
->q
);
441 static inline void __qdisc_reset_queue(struct Qdisc
*sch
,
442 struct sk_buff_head
*list
)
445 * We do not know the backlog in bytes of this list, it
446 * is up to the caller to correct it
448 __skb_queue_purge(list
);
451 static inline void qdisc_reset_queue(struct Qdisc
*sch
)
453 __qdisc_reset_queue(sch
, &sch
->q
);
454 sch
->qstats
.backlog
= 0;
457 static inline unsigned int __qdisc_queue_drop(struct Qdisc
*sch
,
458 struct sk_buff_head
*list
)
460 struct sk_buff
*skb
= __qdisc_dequeue_tail(sch
, list
);
462 if (likely(skb
!= NULL
)) {
463 unsigned int len
= qdisc_pkt_len(skb
);
471 static inline unsigned int qdisc_queue_drop(struct Qdisc
*sch
)
473 return __qdisc_queue_drop(sch
, &sch
->q
);
476 static inline int qdisc_drop(struct sk_buff
*skb
, struct Qdisc
*sch
)
481 return NET_XMIT_DROP
;
484 static inline int qdisc_reshape_fail(struct sk_buff
*skb
, struct Qdisc
*sch
)
488 #ifdef CONFIG_NET_CLS_ACT
489 if (sch
->reshape_fail
== NULL
|| sch
->reshape_fail(skb
, sch
))
492 return NET_XMIT_SUCCESS
;
497 return NET_XMIT_DROP
;
500 /* Length to Time (L2T) lookup in a qdisc_rate_table, to determine how
501 long it will take to send a packet given its size.
503 static inline u32
qdisc_l2t(struct qdisc_rate_table
* rtab
, unsigned int pktlen
)
505 int slot
= pktlen
+ rtab
->rate
.cell_align
+ rtab
->rate
.overhead
;
508 slot
>>= rtab
->rate
.cell_log
;
510 return (rtab
->data
[255]*(slot
>> 8) + rtab
->data
[slot
& 0xFF]);
511 return rtab
->data
[slot
];
514 #ifdef CONFIG_NET_CLS_ACT
515 static inline struct sk_buff
*skb_act_clone(struct sk_buff
*skb
, gfp_t gfp_mask
)
517 struct sk_buff
*n
= skb_clone(skb
, gfp_mask
);
520 n
->tc_verd
= SET_TC_VERD(n
->tc_verd
, 0);
521 n
->tc_verd
= CLR_TC_OK2MUNGE(n
->tc_verd
);
522 n
->tc_verd
= CLR_TC_MUNGED(n
->tc_verd
);