1
2#ifndef __NET_SCHED_GENERIC_H
3#define __NET_SCHED_GENERIC_H
4
5#include <linux/netdevice.h>
6#include <linux/types.h>
7#include <linux/rcupdate.h>
8#include <linux/pkt_sched.h>
9#include <linux/pkt_cls.h>
10#include <linux/percpu.h>
11#include <linux/dynamic_queue_limits.h>
12#include <linux/list.h>
13#include <linux/refcount.h>
14#include <linux/workqueue.h>
15#include <linux/mutex.h>
16#include <net/gen_stats.h>
17#include <net/rtnetlink.h>
18#include <net/flow_offload.h>
19
20struct Qdisc_ops;
21struct qdisc_walker;
22struct tcf_walker;
23struct module;
24struct bpf_flow_keys;
25
26typedef int tc_indr_block_bind_cb_t(struct net_device *dev, void *cb_priv,
27 enum tc_setup_type type, void *type_data);
28
29struct qdisc_rate_table {
30 struct tc_ratespec rate;
31 u32 data[256];
32 struct qdisc_rate_table *next;
33 int refcnt;
34};
35
36enum qdisc_state_t {
37 __QDISC_STATE_SCHED,
38 __QDISC_STATE_DEACTIVATED,
39};
40
41struct qdisc_size_table {
42 struct rcu_head rcu;
43 struct list_head list;
44 struct tc_sizespec szopts;
45 int refcnt;
46 u16 data[];
47};
48
49
50struct qdisc_skb_head {
51 struct sk_buff *head;
52 struct sk_buff *tail;
53 __u32 qlen;
54 spinlock_t lock;
55};
56
57struct Qdisc {
58 int (*enqueue)(struct sk_buff *skb,
59 struct Qdisc *sch,
60 struct sk_buff **to_free);
61 struct sk_buff * (*dequeue)(struct Qdisc *sch);
62 unsigned int flags;
63#define TCQ_F_BUILTIN 1
64#define TCQ_F_INGRESS 2
65#define TCQ_F_CAN_BYPASS 4
66#define TCQ_F_MQROOT 8
67#define TCQ_F_ONETXQUEUE 0x10
68
69
70
71
72
73
74#define TCQ_F_WARN_NONWC (1 << 16)
75#define TCQ_F_CPUSTATS 0x20
76#define TCQ_F_NOPARENT 0x40
77
78
79#define TCQ_F_INVISIBLE 0x80
80#define TCQ_F_NOLOCK 0x100
81#define TCQ_F_OFFLOADED 0x200
82 u32 limit;
83 const struct Qdisc_ops *ops;
84 struct qdisc_size_table __rcu *stab;
85 struct hlist_node hash;
86 u32 handle;
87 u32 parent;
88
89 struct netdev_queue *dev_queue;
90
91 struct net_rate_estimator __rcu *rate_est;
92 struct gnet_stats_basic_cpu __percpu *cpu_bstats;
93 struct gnet_stats_queue __percpu *cpu_qstats;
94 int padded;
95 refcount_t refcnt;
96
97
98
99
100 struct sk_buff_head gso_skb ____cacheline_aligned_in_smp;
101 struct qdisc_skb_head q;
102 struct gnet_stats_basic_packed bstats;
103 seqcount_t running;
104 struct gnet_stats_queue qstats;
105 unsigned long state;
106 struct Qdisc *next_sched;
107 struct sk_buff_head skb_bad_txq;
108
109 spinlock_t busylock ____cacheline_aligned_in_smp;
110 spinlock_t seqlock;
111
112
113 bool empty;
114 struct rcu_head rcu;
115};
116
117static inline void qdisc_refcount_inc(struct Qdisc *qdisc)
118{
119 if (qdisc->flags & TCQ_F_BUILTIN)
120 return;
121 refcount_inc(&qdisc->refcnt);
122}
123
124
125
126
127
128static inline struct Qdisc *qdisc_refcount_inc_nz(struct Qdisc *qdisc)
129{
130 if (qdisc->flags & TCQ_F_BUILTIN)
131 return qdisc;
132 if (refcount_inc_not_zero(&qdisc->refcnt))
133 return qdisc;
134 return NULL;
135}
136
137static inline bool qdisc_is_running(struct Qdisc *qdisc)
138{
139 if (qdisc->flags & TCQ_F_NOLOCK)
140 return spin_is_locked(&qdisc->seqlock);
141 return (raw_read_seqcount(&qdisc->running) & 1) ? true : false;
142}
143
144static inline bool qdisc_is_percpu_stats(const struct Qdisc *q)
145{
146 return q->flags & TCQ_F_CPUSTATS;
147}
148
149static inline bool qdisc_is_empty(const struct Qdisc *qdisc)
150{
151 if (qdisc_is_percpu_stats(qdisc))
152 return qdisc->empty;
153 return !qdisc->q.qlen;
154}
155
156static inline bool qdisc_run_begin(struct Qdisc *qdisc)
157{
158 if (qdisc->flags & TCQ_F_NOLOCK) {
159 if (!spin_trylock(&qdisc->seqlock))
160 return false;
161 qdisc->empty = false;
162 } else if (qdisc_is_running(qdisc)) {
163 return false;
164 }
165
166
167
168 raw_write_seqcount_begin(&qdisc->running);
169 seqcount_acquire(&qdisc->running.dep_map, 0, 1, _RET_IP_);
170 return true;
171}
172
173static inline void qdisc_run_end(struct Qdisc *qdisc)
174{
175 write_seqcount_end(&qdisc->running);
176 if (qdisc->flags & TCQ_F_NOLOCK)
177 spin_unlock(&qdisc->seqlock);
178}
179
180static inline bool qdisc_may_bulk(const struct Qdisc *qdisc)
181{
182 return qdisc->flags & TCQ_F_ONETXQUEUE;
183}
184
185static inline int qdisc_avail_bulklimit(const struct netdev_queue *txq)
186{
187#ifdef CONFIG_BQL
188
189 return dql_avail(&txq->dql);
190#else
191 return 0;
192#endif
193}
194
195struct Qdisc_class_ops {
196 unsigned int flags;
197
198 struct netdev_queue * (*select_queue)(struct Qdisc *, struct tcmsg *);
199 int (*graft)(struct Qdisc *, unsigned long cl,
200 struct Qdisc *, struct Qdisc **,
201 struct netlink_ext_ack *extack);
202 struct Qdisc * (*leaf)(struct Qdisc *, unsigned long cl);
203 void (*qlen_notify)(struct Qdisc *, unsigned long);
204
205
206 unsigned long (*find)(struct Qdisc *, u32 classid);
207 int (*change)(struct Qdisc *, u32, u32,
208 struct nlattr **, unsigned long *,
209 struct netlink_ext_ack *);
210 int (*delete)(struct Qdisc *, unsigned long);
211 void (*walk)(struct Qdisc *, struct qdisc_walker * arg);
212
213
214 struct tcf_block * (*tcf_block)(struct Qdisc *sch,
215 unsigned long arg,
216 struct netlink_ext_ack *extack);
217 unsigned long (*bind_tcf)(struct Qdisc *, unsigned long,
218 u32 classid);
219 void (*unbind_tcf)(struct Qdisc *, unsigned long);
220
221
222 int (*dump)(struct Qdisc *, unsigned long,
223 struct sk_buff *skb, struct tcmsg*);
224 int (*dump_stats)(struct Qdisc *, unsigned long,
225 struct gnet_dump *);
226};
227
228
229
230
231enum qdisc_class_ops_flags {
232 QDISC_CLASS_OPS_DOIT_UNLOCKED = 1,
233};
234
235struct Qdisc_ops {
236 struct Qdisc_ops *next;
237 const struct Qdisc_class_ops *cl_ops;
238 char id[IFNAMSIZ];
239 int priv_size;
240 unsigned int static_flags;
241
242 int (*enqueue)(struct sk_buff *skb,
243 struct Qdisc *sch,
244 struct sk_buff **to_free);
245 struct sk_buff * (*dequeue)(struct Qdisc *);
246 struct sk_buff * (*peek)(struct Qdisc *);
247
248 int (*init)(struct Qdisc *sch, struct nlattr *arg,
249 struct netlink_ext_ack *extack);
250 void (*reset)(struct Qdisc *);
251 void (*destroy)(struct Qdisc *);
252 int (*change)(struct Qdisc *sch,
253 struct nlattr *arg,
254 struct netlink_ext_ack *extack);
255 void (*attach)(struct Qdisc *sch);
256 int (*change_tx_queue_len)(struct Qdisc *, unsigned int);
257
258 int (*dump)(struct Qdisc *, struct sk_buff *);
259 int (*dump_stats)(struct Qdisc *, struct gnet_dump *);
260
261 void (*ingress_block_set)(struct Qdisc *sch,
262 u32 block_index);
263 void (*egress_block_set)(struct Qdisc *sch,
264 u32 block_index);
265 u32 (*ingress_block_get)(struct Qdisc *sch);
266 u32 (*egress_block_get)(struct Qdisc *sch);
267
268 struct module *owner;
269};
270
271
272struct tcf_result {
273 union {
274 struct {
275 unsigned long class;
276 u32 classid;
277 };
278 const struct tcf_proto *goto_tp;
279
280
281 struct {
282 bool ingress;
283 struct gnet_stats_queue *qstats;
284 };
285 };
286};
287
288struct tcf_chain;
289
290struct tcf_proto_ops {
291 struct list_head head;
292 char kind[IFNAMSIZ];
293
294 int (*classify)(struct sk_buff *,
295 const struct tcf_proto *,
296 struct tcf_result *);
297 int (*init)(struct tcf_proto*);
298 void (*destroy)(struct tcf_proto *tp, bool rtnl_held,
299 struct netlink_ext_ack *extack);
300
301 void* (*get)(struct tcf_proto*, u32 handle);
302 void (*put)(struct tcf_proto *tp, void *f);
303 int (*change)(struct net *net, struct sk_buff *,
304 struct tcf_proto*, unsigned long,
305 u32 handle, struct nlattr **,
306 void **, bool, bool,
307 struct netlink_ext_ack *);
308 int (*delete)(struct tcf_proto *tp, void *arg,
309 bool *last, bool rtnl_held,
310 struct netlink_ext_ack *);
311 void (*walk)(struct tcf_proto *tp,
312 struct tcf_walker *arg, bool rtnl_held);
313 int (*reoffload)(struct tcf_proto *tp, bool add,
314 flow_setup_cb_t *cb, void *cb_priv,
315 struct netlink_ext_ack *extack);
316 void (*bind_class)(void *, u32, unsigned long);
317 void * (*tmplt_create)(struct net *net,
318 struct tcf_chain *chain,
319 struct nlattr **tca,
320 struct netlink_ext_ack *extack);
321 void (*tmplt_destroy)(void *tmplt_priv);
322
323
324 int (*dump)(struct net*, struct tcf_proto*, void *,
325 struct sk_buff *skb, struct tcmsg*,
326 bool);
327 int (*tmplt_dump)(struct sk_buff *skb,
328 struct net *net,
329 void *tmplt_priv);
330
331 struct module *owner;
332 int flags;
333};
334
335enum tcf_proto_ops_flags {
336 TCF_PROTO_OPS_DOIT_UNLOCKED = 1,
337};
338
339struct tcf_proto {
340
341 struct tcf_proto __rcu *next;
342 void __rcu *root;
343
344
345 int (*classify)(struct sk_buff *,
346 const struct tcf_proto *,
347 struct tcf_result *);
348 __be16 protocol;
349
350
351 u32 prio;
352 void *data;
353 const struct tcf_proto_ops *ops;
354 struct tcf_chain *chain;
355
356
357
358 spinlock_t lock;
359 bool deleting;
360 refcount_t refcnt;
361 struct rcu_head rcu;
362};
363
364struct qdisc_skb_cb {
365 struct {
366 unsigned int pkt_len;
367 u16 slave_dev_queue_mapping;
368 u16 tc_classid;
369 };
370#define QDISC_CB_PRIV_LEN 20
371 unsigned char data[QDISC_CB_PRIV_LEN];
372};
373
374typedef void tcf_chain_head_change_t(struct tcf_proto *tp_head, void *priv);
375
376struct tcf_chain {
377
378 struct mutex filter_chain_lock;
379 struct tcf_proto __rcu *filter_chain;
380 struct list_head list;
381 struct tcf_block *block;
382 u32 index;
383 unsigned int refcnt;
384 unsigned int action_refcnt;
385 bool explicitly_created;
386 bool flushing;
387 const struct tcf_proto_ops *tmplt_ops;
388 void *tmplt_priv;
389 struct rcu_head rcu;
390};
391
392struct tcf_block {
393
394
395
396 struct mutex lock;
397 struct list_head chain_list;
398 u32 index;
399 refcount_t refcnt;
400 struct net *net;
401 struct Qdisc *q;
402 struct flow_block flow_block;
403 struct list_head owner_list;
404 bool keep_dst;
405 unsigned int offloadcnt;
406 unsigned int nooffloaddevcnt;
407 struct {
408 struct tcf_chain *chain;
409 struct list_head filter_chain_list;
410 } chain0;
411 struct rcu_head rcu;
412};
413
414#ifdef CONFIG_PROVE_LOCKING
415static inline bool lockdep_tcf_chain_is_locked(struct tcf_chain *chain)
416{
417 return lockdep_is_held(&chain->filter_chain_lock);
418}
419
420static inline bool lockdep_tcf_proto_is_locked(struct tcf_proto *tp)
421{
422 return lockdep_is_held(&tp->lock);
423}
424#else
425static inline bool lockdep_tcf_chain_is_locked(struct tcf_block *chain)
426{
427 return true;
428}
429
430static inline bool lockdep_tcf_proto_is_locked(struct tcf_proto *tp)
431{
432 return true;
433}
434#endif
435
436#define tcf_chain_dereference(p, chain) \
437 rcu_dereference_protected(p, lockdep_tcf_chain_is_locked(chain))
438
439#define tcf_proto_dereference(p, tp) \
440 rcu_dereference_protected(p, lockdep_tcf_proto_is_locked(tp))
441
442static inline void tcf_block_offload_inc(struct tcf_block *block, u32 *flags)
443{
444 if (*flags & TCA_CLS_FLAGS_IN_HW)
445 return;
446 *flags |= TCA_CLS_FLAGS_IN_HW;
447 block->offloadcnt++;
448}
449
450static inline void tcf_block_offload_dec(struct tcf_block *block, u32 *flags)
451{
452 if (!(*flags & TCA_CLS_FLAGS_IN_HW))
453 return;
454 *flags &= ~TCA_CLS_FLAGS_IN_HW;
455 block->offloadcnt--;
456}
457
458static inline void
459tc_cls_offload_cnt_update(struct tcf_block *block, u32 *cnt,
460 u32 *flags, bool add)
461{
462 if (add) {
463 if (!*cnt)
464 tcf_block_offload_inc(block, flags);
465 (*cnt)++;
466 } else {
467 (*cnt)--;
468 if (!*cnt)
469 tcf_block_offload_dec(block, flags);
470 }
471}
472
473static inline void qdisc_cb_private_validate(const struct sk_buff *skb, int sz)
474{
475 struct qdisc_skb_cb *qcb;
476
477 BUILD_BUG_ON(sizeof(skb->cb) < offsetof(struct qdisc_skb_cb, data) + sz);
478 BUILD_BUG_ON(sizeof(qcb->data) < sz);
479}
480
481static inline int qdisc_qlen_cpu(const struct Qdisc *q)
482{
483 return this_cpu_ptr(q->cpu_qstats)->qlen;
484}
485
486static inline int qdisc_qlen(const struct Qdisc *q)
487{
488 return q->q.qlen;
489}
490
491static inline int qdisc_qlen_sum(const struct Qdisc *q)
492{
493 __u32 qlen = q->qstats.qlen;
494 int i;
495
496 if (qdisc_is_percpu_stats(q)) {
497 for_each_possible_cpu(i)
498 qlen += per_cpu_ptr(q->cpu_qstats, i)->qlen;
499 } else {
500 qlen += q->q.qlen;
501 }
502
503 return qlen;
504}
505
506static inline struct qdisc_skb_cb *qdisc_skb_cb(const struct sk_buff *skb)
507{
508 return (struct qdisc_skb_cb *)skb->cb;
509}
510
511static inline spinlock_t *qdisc_lock(struct Qdisc *qdisc)
512{
513 return &qdisc->q.lock;
514}
515
516static inline struct Qdisc *qdisc_root(const struct Qdisc *qdisc)
517{
518 struct Qdisc *q = rcu_dereference_rtnl(qdisc->dev_queue->qdisc);
519
520 return q;
521}
522
523static inline struct Qdisc *qdisc_root_sleeping(const struct Qdisc *qdisc)
524{
525 return qdisc->dev_queue->qdisc_sleeping;
526}
527
528
529
530
531
532
533
534
535
536
537
538
539static inline spinlock_t *qdisc_root_lock(const struct Qdisc *qdisc)
540{
541 struct Qdisc *root = qdisc_root(qdisc);
542
543 ASSERT_RTNL();
544 return qdisc_lock(root);
545}
546
547static inline spinlock_t *qdisc_root_sleeping_lock(const struct Qdisc *qdisc)
548{
549 struct Qdisc *root = qdisc_root_sleeping(qdisc);
550
551 ASSERT_RTNL();
552 return qdisc_lock(root);
553}
554
555static inline seqcount_t *qdisc_root_sleeping_running(const struct Qdisc *qdisc)
556{
557 struct Qdisc *root = qdisc_root_sleeping(qdisc);
558
559 ASSERT_RTNL();
560 return &root->running;
561}
562
563static inline struct net_device *qdisc_dev(const struct Qdisc *qdisc)
564{
565 return qdisc->dev_queue->dev;
566}
567
568static inline void sch_tree_lock(const struct Qdisc *q)
569{
570 spin_lock_bh(qdisc_root_sleeping_lock(q));
571}
572
573static inline void sch_tree_unlock(const struct Qdisc *q)
574{
575 spin_unlock_bh(qdisc_root_sleeping_lock(q));
576}
577
578extern struct Qdisc noop_qdisc;
579extern struct Qdisc_ops noop_qdisc_ops;
580extern struct Qdisc_ops pfifo_fast_ops;
581extern struct Qdisc_ops mq_qdisc_ops;
582extern struct Qdisc_ops noqueue_qdisc_ops;
583extern const struct Qdisc_ops *default_qdisc_ops;
584static inline const struct Qdisc_ops *
585get_default_qdisc_ops(const struct net_device *dev, int ntx)
586{
587 return ntx < dev->real_num_tx_queues ?
588 default_qdisc_ops : &pfifo_fast_ops;
589}
590
591struct Qdisc_class_common {
592 u32 classid;
593 struct hlist_node hnode;
594};
595
596struct Qdisc_class_hash {
597 struct hlist_head *hash;
598 unsigned int hashsize;
599 unsigned int hashmask;
600 unsigned int hashelems;
601};
602
603static inline unsigned int qdisc_class_hash(u32 id, u32 mask)
604{
605 id ^= id >> 8;
606 id ^= id >> 4;
607 return id & mask;
608}
609
610static inline struct Qdisc_class_common *
611qdisc_class_find(const struct Qdisc_class_hash *hash, u32 id)
612{
613 struct Qdisc_class_common *cl;
614 unsigned int h;
615
616 if (!id)
617 return NULL;
618
619 h = qdisc_class_hash(id, hash->hashmask);
620 hlist_for_each_entry(cl, &hash->hash[h], hnode) {
621 if (cl->classid == id)
622 return cl;
623 }
624 return NULL;
625}
626
627static inline int tc_classid_to_hwtc(struct net_device *dev, u32 classid)
628{
629 u32 hwtc = TC_H_MIN(classid) - TC_H_MIN_PRIORITY;
630
631 return (hwtc < netdev_get_num_tc(dev)) ? hwtc : -EINVAL;
632}
633
634int qdisc_class_hash_init(struct Qdisc_class_hash *);
635void qdisc_class_hash_insert(struct Qdisc_class_hash *,
636 struct Qdisc_class_common *);
637void qdisc_class_hash_remove(struct Qdisc_class_hash *,
638 struct Qdisc_class_common *);
639void qdisc_class_hash_grow(struct Qdisc *, struct Qdisc_class_hash *);
640void qdisc_class_hash_destroy(struct Qdisc_class_hash *);
641
642int dev_qdisc_change_tx_queue_len(struct net_device *dev);
643void dev_init_scheduler(struct net_device *dev);
644void dev_shutdown(struct net_device *dev);
645void dev_activate(struct net_device *dev);
646void dev_deactivate(struct net_device *dev);
647void dev_deactivate_many(struct list_head *head);
648struct Qdisc *dev_graft_qdisc(struct netdev_queue *dev_queue,
649 struct Qdisc *qdisc);
650void qdisc_reset(struct Qdisc *qdisc);
651void qdisc_put(struct Qdisc *qdisc);
652void qdisc_put_unlocked(struct Qdisc *qdisc);
653void qdisc_tree_reduce_backlog(struct Qdisc *qdisc, int n, int len);
654#ifdef CONFIG_NET_SCHED
655int qdisc_offload_dump_helper(struct Qdisc *q, enum tc_setup_type type,
656 void *type_data);
657void qdisc_offload_graft_helper(struct net_device *dev, struct Qdisc *sch,
658 struct Qdisc *new, struct Qdisc *old,
659 enum tc_setup_type type, void *type_data,
660 struct netlink_ext_ack *extack);
661#else
662static inline int
663qdisc_offload_dump_helper(struct Qdisc *q, enum tc_setup_type type,
664 void *type_data)
665{
666 q->flags &= ~TCQ_F_OFFLOADED;
667 return 0;
668}
669
670static inline void
671qdisc_offload_graft_helper(struct net_device *dev, struct Qdisc *sch,
672 struct Qdisc *new, struct Qdisc *old,
673 enum tc_setup_type type, void *type_data,
674 struct netlink_ext_ack *extack)
675{
676}
677#endif
678struct Qdisc *qdisc_alloc(struct netdev_queue *dev_queue,
679 const struct Qdisc_ops *ops,
680 struct netlink_ext_ack *extack);
681void qdisc_free(struct Qdisc *qdisc);
682struct Qdisc *qdisc_create_dflt(struct netdev_queue *dev_queue,
683 const struct Qdisc_ops *ops, u32 parentid,
684 struct netlink_ext_ack *extack);
685void __qdisc_calculate_pkt_len(struct sk_buff *skb,
686 const struct qdisc_size_table *stab);
687int skb_do_redirect(struct sk_buff *);
688
689static inline void skb_reset_tc(struct sk_buff *skb)
690{
691#ifdef CONFIG_NET_CLS_ACT
692 skb->tc_redirected = 0;
693#endif
694}
695
696static inline bool skb_is_tc_redirected(const struct sk_buff *skb)
697{
698#ifdef CONFIG_NET_CLS_ACT
699 return skb->tc_redirected;
700#else
701 return false;
702#endif
703}
704
705static inline bool skb_at_tc_ingress(const struct sk_buff *skb)
706{
707#ifdef CONFIG_NET_CLS_ACT
708 return skb->tc_at_ingress;
709#else
710 return false;
711#endif
712}
713
714static inline bool skb_skip_tc_classify(struct sk_buff *skb)
715{
716#ifdef CONFIG_NET_CLS_ACT
717 if (skb->tc_skip_classify) {
718 skb->tc_skip_classify = 0;
719 return true;
720 }
721#endif
722 return false;
723}
724
725
726static inline void qdisc_reset_all_tx_gt(struct net_device *dev, unsigned int i)
727{
728 struct Qdisc *qdisc;
729
730 for (; i < dev->num_tx_queues; i++) {
731 qdisc = rtnl_dereference(netdev_get_tx_queue(dev, i)->qdisc);
732 if (qdisc) {
733 spin_lock_bh(qdisc_lock(qdisc));
734 qdisc_reset(qdisc);
735 spin_unlock_bh(qdisc_lock(qdisc));
736 }
737 }
738}
739
740static inline void qdisc_reset_all_tx(struct net_device *dev)
741{
742 qdisc_reset_all_tx_gt(dev, 0);
743}
744
745
746static inline bool qdisc_all_tx_empty(const struct net_device *dev)
747{
748 unsigned int i;
749
750 rcu_read_lock();
751 for (i = 0; i < dev->num_tx_queues; i++) {
752 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
753 const struct Qdisc *q = rcu_dereference(txq->qdisc);
754
755 if (!qdisc_is_empty(q)) {
756 rcu_read_unlock();
757 return false;
758 }
759 }
760 rcu_read_unlock();
761 return true;
762}
763
764
765static inline bool qdisc_tx_changing(const struct net_device *dev)
766{
767 unsigned int i;
768
769 for (i = 0; i < dev->num_tx_queues; i++) {
770 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
771 if (rcu_access_pointer(txq->qdisc) != txq->qdisc_sleeping)
772 return true;
773 }
774 return false;
775}
776
777
778static inline bool qdisc_tx_is_noop(const struct net_device *dev)
779{
780 unsigned int i;
781
782 for (i = 0; i < dev->num_tx_queues; i++) {
783 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
784 if (rcu_access_pointer(txq->qdisc) != &noop_qdisc)
785 return false;
786 }
787 return true;
788}
789
790static inline unsigned int qdisc_pkt_len(const struct sk_buff *skb)
791{
792 return qdisc_skb_cb(skb)->pkt_len;
793}
794
795
796enum net_xmit_qdisc_t {
797 __NET_XMIT_STOLEN = 0x00010000,
798 __NET_XMIT_BYPASS = 0x00020000,
799};
800
801#ifdef CONFIG_NET_CLS_ACT
802#define net_xmit_drop_count(e) ((e) & __NET_XMIT_STOLEN ? 0 : 1)
803#else
804#define net_xmit_drop_count(e) (1)
805#endif
806
807static inline void qdisc_calculate_pkt_len(struct sk_buff *skb,
808 const struct Qdisc *sch)
809{
810#ifdef CONFIG_NET_SCHED
811 struct qdisc_size_table *stab = rcu_dereference_bh(sch->stab);
812
813 if (stab)
814 __qdisc_calculate_pkt_len(skb, stab);
815#endif
816}
817
818static inline int qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch,
819 struct sk_buff **to_free)
820{
821 qdisc_calculate_pkt_len(skb, sch);
822 return sch->enqueue(skb, sch, to_free);
823}
824
825static inline void _bstats_update(struct gnet_stats_basic_packed *bstats,
826 __u64 bytes, __u32 packets)
827{
828 bstats->bytes += bytes;
829 bstats->packets += packets;
830}
831
832static inline void bstats_update(struct gnet_stats_basic_packed *bstats,
833 const struct sk_buff *skb)
834{
835 _bstats_update(bstats,
836 qdisc_pkt_len(skb),
837 skb_is_gso(skb) ? skb_shinfo(skb)->gso_segs : 1);
838}
839
840static inline void _bstats_cpu_update(struct gnet_stats_basic_cpu *bstats,
841 __u64 bytes, __u32 packets)
842{
843 u64_stats_update_begin(&bstats->syncp);
844 _bstats_update(&bstats->bstats, bytes, packets);
845 u64_stats_update_end(&bstats->syncp);
846}
847
848static inline void bstats_cpu_update(struct gnet_stats_basic_cpu *bstats,
849 const struct sk_buff *skb)
850{
851 u64_stats_update_begin(&bstats->syncp);
852 bstats_update(&bstats->bstats, skb);
853 u64_stats_update_end(&bstats->syncp);
854}
855
856static inline void qdisc_bstats_cpu_update(struct Qdisc *sch,
857 const struct sk_buff *skb)
858{
859 bstats_cpu_update(this_cpu_ptr(sch->cpu_bstats), skb);
860}
861
862static inline void qdisc_bstats_update(struct Qdisc *sch,
863 const struct sk_buff *skb)
864{
865 bstats_update(&sch->bstats, skb);
866}
867
868static inline void qdisc_qstats_backlog_dec(struct Qdisc *sch,
869 const struct sk_buff *skb)
870{
871 sch->qstats.backlog -= qdisc_pkt_len(skb);
872}
873
874static inline void qdisc_qstats_cpu_backlog_dec(struct Qdisc *sch,
875 const struct sk_buff *skb)
876{
877 this_cpu_sub(sch->cpu_qstats->backlog, qdisc_pkt_len(skb));
878}
879
880static inline void qdisc_qstats_backlog_inc(struct Qdisc *sch,
881 const struct sk_buff *skb)
882{
883 sch->qstats.backlog += qdisc_pkt_len(skb);
884}
885
886static inline void qdisc_qstats_cpu_backlog_inc(struct Qdisc *sch,
887 const struct sk_buff *skb)
888{
889 this_cpu_add(sch->cpu_qstats->backlog, qdisc_pkt_len(skb));
890}
891
892static inline void qdisc_qstats_cpu_qlen_inc(struct Qdisc *sch)
893{
894 this_cpu_inc(sch->cpu_qstats->qlen);
895}
896
897static inline void qdisc_qstats_cpu_qlen_dec(struct Qdisc *sch)
898{
899 this_cpu_dec(sch->cpu_qstats->qlen);
900}
901
902static inline void qdisc_qstats_cpu_requeues_inc(struct Qdisc *sch)
903{
904 this_cpu_inc(sch->cpu_qstats->requeues);
905}
906
907static inline void __qdisc_qstats_drop(struct Qdisc *sch, int count)
908{
909 sch->qstats.drops += count;
910}
911
912static inline void qstats_drop_inc(struct gnet_stats_queue *qstats)
913{
914 qstats->drops++;
915}
916
917static inline void qstats_overlimit_inc(struct gnet_stats_queue *qstats)
918{
919 qstats->overlimits++;
920}
921
922static inline void qdisc_qstats_drop(struct Qdisc *sch)
923{
924 qstats_drop_inc(&sch->qstats);
925}
926
927static inline void qdisc_qstats_cpu_drop(struct Qdisc *sch)
928{
929 this_cpu_inc(sch->cpu_qstats->drops);
930}
931
932static inline void qdisc_qstats_overlimit(struct Qdisc *sch)
933{
934 sch->qstats.overlimits++;
935}
936
937static inline int qdisc_qstats_copy(struct gnet_dump *d, struct Qdisc *sch)
938{
939 __u32 qlen = qdisc_qlen_sum(sch);
940
941 return gnet_stats_copy_queue(d, sch->cpu_qstats, &sch->qstats, qlen);
942}
943
944static inline void qdisc_qstats_qlen_backlog(struct Qdisc *sch, __u32 *qlen,
945 __u32 *backlog)
946{
947 struct gnet_stats_queue qstats = { 0 };
948 __u32 len = qdisc_qlen_sum(sch);
949
950 __gnet_stats_copy_queue(&qstats, sch->cpu_qstats, &sch->qstats, len);
951 *qlen = qstats.qlen;
952 *backlog = qstats.backlog;
953}
954
955static inline void qdisc_tree_flush_backlog(struct Qdisc *sch)
956{
957 __u32 qlen, backlog;
958
959 qdisc_qstats_qlen_backlog(sch, &qlen, &backlog);
960 qdisc_tree_reduce_backlog(sch, qlen, backlog);
961}
962
963static inline void qdisc_purge_queue(struct Qdisc *sch)
964{
965 __u32 qlen, backlog;
966
967 qdisc_qstats_qlen_backlog(sch, &qlen, &backlog);
968 qdisc_reset(sch);
969 qdisc_tree_reduce_backlog(sch, qlen, backlog);
970}
971
972static inline void qdisc_skb_head_init(struct qdisc_skb_head *qh)
973{
974 qh->head = NULL;
975 qh->tail = NULL;
976 qh->qlen = 0;
977}
978
979static inline void __qdisc_enqueue_tail(struct sk_buff *skb,
980 struct qdisc_skb_head *qh)
981{
982 struct sk_buff *last = qh->tail;
983
984 if (last) {
985 skb->next = NULL;
986 last->next = skb;
987 qh->tail = skb;
988 } else {
989 qh->tail = skb;
990 qh->head = skb;
991 }
992 qh->qlen++;
993}
994
995static inline int qdisc_enqueue_tail(struct sk_buff *skb, struct Qdisc *sch)
996{
997 __qdisc_enqueue_tail(skb, &sch->q);
998 qdisc_qstats_backlog_inc(sch, skb);
999 return NET_XMIT_SUCCESS;
1000}
1001
1002static inline void __qdisc_enqueue_head(struct sk_buff *skb,
1003 struct qdisc_skb_head *qh)
1004{
1005 skb->next = qh->head;
1006
1007 if (!qh->head)
1008 qh->tail = skb;
1009 qh->head = skb;
1010 qh->qlen++;
1011}
1012
1013static inline struct sk_buff *__qdisc_dequeue_head(struct qdisc_skb_head *qh)
1014{
1015 struct sk_buff *skb = qh->head;
1016
1017 if (likely(skb != NULL)) {
1018 qh->head = skb->next;
1019 qh->qlen--;
1020 if (qh->head == NULL)
1021 qh->tail = NULL;
1022 skb->next = NULL;
1023 }
1024
1025 return skb;
1026}
1027
1028static inline struct sk_buff *qdisc_dequeue_head(struct Qdisc *sch)
1029{
1030 struct sk_buff *skb = __qdisc_dequeue_head(&sch->q);
1031
1032 if (likely(skb != NULL)) {
1033 qdisc_qstats_backlog_dec(sch, skb);
1034 qdisc_bstats_update(sch, skb);
1035 }
1036
1037 return skb;
1038}
1039
1040
1041
1042
1043static inline void __qdisc_drop(struct sk_buff *skb, struct sk_buff **to_free)
1044{
1045 skb->next = *to_free;
1046 *to_free = skb;
1047}
1048
1049static inline void __qdisc_drop_all(struct sk_buff *skb,
1050 struct sk_buff **to_free)
1051{
1052 if (skb->prev)
1053 skb->prev->next = *to_free;
1054 else
1055 skb->next = *to_free;
1056 *to_free = skb;
1057}
1058
1059static inline unsigned int __qdisc_queue_drop_head(struct Qdisc *sch,
1060 struct qdisc_skb_head *qh,
1061 struct sk_buff **to_free)
1062{
1063 struct sk_buff *skb = __qdisc_dequeue_head(qh);
1064
1065 if (likely(skb != NULL)) {
1066 unsigned int len = qdisc_pkt_len(skb);
1067
1068 qdisc_qstats_backlog_dec(sch, skb);
1069 __qdisc_drop(skb, to_free);
1070 return len;
1071 }
1072
1073 return 0;
1074}
1075
1076static inline unsigned int qdisc_queue_drop_head(struct Qdisc *sch,
1077 struct sk_buff **to_free)
1078{
1079 return __qdisc_queue_drop_head(sch, &sch->q, to_free);
1080}
1081
1082static inline struct sk_buff *qdisc_peek_head(struct Qdisc *sch)
1083{
1084 const struct qdisc_skb_head *qh = &sch->q;
1085
1086 return qh->head;
1087}
1088
1089
1090static inline struct sk_buff *qdisc_peek_dequeued(struct Qdisc *sch)
1091{
1092 struct sk_buff *skb = skb_peek(&sch->gso_skb);
1093
1094
1095 if (!skb) {
1096 skb = sch->dequeue(sch);
1097
1098 if (skb) {
1099 __skb_queue_head(&sch->gso_skb, skb);
1100
1101 qdisc_qstats_backlog_inc(sch, skb);
1102 sch->q.qlen++;
1103 }
1104 }
1105
1106 return skb;
1107}
1108
1109static inline void qdisc_update_stats_at_dequeue(struct Qdisc *sch,
1110 struct sk_buff *skb)
1111{
1112 if (qdisc_is_percpu_stats(sch)) {
1113 qdisc_qstats_cpu_backlog_dec(sch, skb);
1114 qdisc_bstats_cpu_update(sch, skb);
1115 qdisc_qstats_cpu_qlen_dec(sch);
1116 } else {
1117 qdisc_qstats_backlog_dec(sch, skb);
1118 qdisc_bstats_update(sch, skb);
1119 sch->q.qlen--;
1120 }
1121}
1122
1123static inline void qdisc_update_stats_at_enqueue(struct Qdisc *sch,
1124 unsigned int pkt_len)
1125{
1126 if (qdisc_is_percpu_stats(sch)) {
1127 qdisc_qstats_cpu_qlen_inc(sch);
1128 this_cpu_add(sch->cpu_qstats->backlog, pkt_len);
1129 } else {
1130 sch->qstats.backlog += pkt_len;
1131 sch->q.qlen++;
1132 }
1133}
1134
1135
1136static inline struct sk_buff *qdisc_dequeue_peeked(struct Qdisc *sch)
1137{
1138 struct sk_buff *skb = skb_peek(&sch->gso_skb);
1139
1140 if (skb) {
1141 skb = __skb_dequeue(&sch->gso_skb);
1142 if (qdisc_is_percpu_stats(sch)) {
1143 qdisc_qstats_cpu_backlog_dec(sch, skb);
1144 qdisc_qstats_cpu_qlen_dec(sch);
1145 } else {
1146 qdisc_qstats_backlog_dec(sch, skb);
1147 sch->q.qlen--;
1148 }
1149 } else {
1150 skb = sch->dequeue(sch);
1151 }
1152
1153 return skb;
1154}
1155
1156static inline void __qdisc_reset_queue(struct qdisc_skb_head *qh)
1157{
1158
1159
1160
1161
1162 ASSERT_RTNL();
1163 if (qh->qlen) {
1164 rtnl_kfree_skbs(qh->head, qh->tail);
1165
1166 qh->head = NULL;
1167 qh->tail = NULL;
1168 qh->qlen = 0;
1169 }
1170}
1171
1172static inline void qdisc_reset_queue(struct Qdisc *sch)
1173{
1174 __qdisc_reset_queue(&sch->q);
1175 sch->qstats.backlog = 0;
1176}
1177
1178static inline struct Qdisc *qdisc_replace(struct Qdisc *sch, struct Qdisc *new,
1179 struct Qdisc **pold)
1180{
1181 struct Qdisc *old;
1182
1183 sch_tree_lock(sch);
1184 old = *pold;
1185 *pold = new;
1186 if (old != NULL)
1187 qdisc_tree_flush_backlog(old);
1188 sch_tree_unlock(sch);
1189
1190 return old;
1191}
1192
1193static inline void rtnl_qdisc_drop(struct sk_buff *skb, struct Qdisc *sch)
1194{
1195 rtnl_kfree_skbs(skb, skb);
1196 qdisc_qstats_drop(sch);
1197}
1198
1199static inline int qdisc_drop_cpu(struct sk_buff *skb, struct Qdisc *sch,
1200 struct sk_buff **to_free)
1201{
1202 __qdisc_drop(skb, to_free);
1203 qdisc_qstats_cpu_drop(sch);
1204
1205 return NET_XMIT_DROP;
1206}
1207
1208static inline int qdisc_drop(struct sk_buff *skb, struct Qdisc *sch,
1209 struct sk_buff **to_free)
1210{
1211 __qdisc_drop(skb, to_free);
1212 qdisc_qstats_drop(sch);
1213
1214 return NET_XMIT_DROP;
1215}
1216
1217static inline int qdisc_drop_all(struct sk_buff *skb, struct Qdisc *sch,
1218 struct sk_buff **to_free)
1219{
1220 __qdisc_drop_all(skb, to_free);
1221 qdisc_qstats_drop(sch);
1222
1223 return NET_XMIT_DROP;
1224}
1225
1226
1227
1228
1229static inline u32 qdisc_l2t(struct qdisc_rate_table* rtab, unsigned int pktlen)
1230{
1231 int slot = pktlen + rtab->rate.cell_align + rtab->rate.overhead;
1232 if (slot < 0)
1233 slot = 0;
1234 slot >>= rtab->rate.cell_log;
1235 if (slot > 255)
1236 return rtab->data[255]*(slot >> 8) + rtab->data[slot & 0xFF];
1237 return rtab->data[slot];
1238}
1239
1240struct psched_ratecfg {
1241 u64 rate_bytes_ps;
1242 u32 mult;
1243 u16 overhead;
1244 u8 linklayer;
1245 u8 shift;
1246};
1247
1248static inline u64 psched_l2t_ns(const struct psched_ratecfg *r,
1249 unsigned int len)
1250{
1251 len += r->overhead;
1252
1253 if (unlikely(r->linklayer == TC_LINKLAYER_ATM))
1254 return ((u64)(DIV_ROUND_UP(len,48)*53) * r->mult) >> r->shift;
1255
1256 return ((u64)len * r->mult) >> r->shift;
1257}
1258
1259void psched_ratecfg_precompute(struct psched_ratecfg *r,
1260 const struct tc_ratespec *conf,
1261 u64 rate64);
1262
1263static inline void psched_ratecfg_getrate(struct tc_ratespec *res,
1264 const struct psched_ratecfg *r)
1265{
1266 memset(res, 0, sizeof(*res));
1267
1268
1269
1270
1271
1272 res->rate = min_t(u64, r->rate_bytes_ps, ~0U);
1273
1274 res->overhead = r->overhead;
1275 res->linklayer = (r->linklayer & TC_LINKLAYER_MASK);
1276}
1277
1278
1279
1280
1281struct mini_Qdisc {
1282 struct tcf_proto *filter_list;
1283 struct gnet_stats_basic_cpu __percpu *cpu_bstats;
1284 struct gnet_stats_queue __percpu *cpu_qstats;
1285 struct rcu_head rcu;
1286};
1287
1288static inline void mini_qdisc_bstats_cpu_update(struct mini_Qdisc *miniq,
1289 const struct sk_buff *skb)
1290{
1291 bstats_cpu_update(this_cpu_ptr(miniq->cpu_bstats), skb);
1292}
1293
1294static inline void mini_qdisc_qstats_cpu_drop(struct mini_Qdisc *miniq)
1295{
1296 this_cpu_inc(miniq->cpu_qstats->drops);
1297}
1298
1299struct mini_Qdisc_pair {
1300 struct mini_Qdisc miniq1;
1301 struct mini_Qdisc miniq2;
1302 struct mini_Qdisc __rcu **p_miniq;
1303};
1304
1305void mini_qdisc_pair_swap(struct mini_Qdisc_pair *miniqp,
1306 struct tcf_proto *tp_head);
1307void mini_qdisc_pair_init(struct mini_Qdisc_pair *miniqp, struct Qdisc *qdisc,
1308 struct mini_Qdisc __rcu **p_miniq);
1309
1310static inline void skb_tc_reinsert(struct sk_buff *skb, struct tcf_result *res)
1311{
1312 struct gnet_stats_queue *stats = res->qstats;
1313 int ret;
1314
1315 if (res->ingress)
1316 ret = netif_receive_skb(skb);
1317 else
1318 ret = dev_queue_xmit(skb);
1319 if (ret && stats)
1320 qstats_overlimit_inc(res->qstats);
1321}
1322
1323#endif
1324