?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
btrfs: migrate the block group ref counting stuff
[linux/fpc-iii.git] / include / net / sch_generic.h
blob6b6b01234dd9d916d969baced8b784bc2740d805
1 /* SPDX-License-Identifier: GPL-2.0 */
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
20 struct Qdisc_ops;
21 struct qdisc_walker;
22 struct tcf_walker;
23 struct module;
24 struct bpf_flow_keys;
25
26 typedef int tc_indr_block_bind_cb_t(struct net_device *dev, void *cb_priv,
27 enum tc_setup_type type, void *type_data);
28
29 struct qdisc_rate_table {
30 struct tc_ratespec rate;
31 u32 data[256];
32 struct qdisc_rate_table *next;
33 int refcnt;
34 };
35
36 enum qdisc_state_t {
37 __QDISC_STATE_SCHED,
38 __QDISC_STATE_DEACTIVATED,
39 };
40
41 struct 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 /* similar to sk_buff_head, but skb->prev pointer is undefined. */
50 struct qdisc_skb_head {
51 struct sk_buff *head;
52 struct sk_buff *tail;
53 __u32 qlen;
54 spinlock_t lock;
55 };
56
57 struct 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 /* dequeue_skb() can assume all skbs are for
68 * q->dev_queue : It can test
69 * netif_xmit_frozen_or_stopped() before
70 * dequeueing next packet.
71 * Its true for MQ/MQPRIO slaves, or non
72 * multiqueue device.
73 */
74 #define TCQ_F_WARN_NONWC (1 << 16)
75 #define TCQ_F_CPUSTATS 0x20 /* run using percpu statistics */
76 #define TCQ_F_NOPARENT 0x40 /* root of its hierarchy :
77 * qdisc_tree_decrease_qlen() should stop.
78 */
79 #define TCQ_F_INVISIBLE 0x80 /* invisible by default in dump */
80 #define TCQ_F_NOLOCK 0x100 /* qdisc does not require locking */
81 #define TCQ_F_OFFLOADED 0x200 /* qdisc is offloaded to HW */
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 * For performance sake on SMP, we put highly modified fields at the end
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 /* for NOLOCK qdisc, true if there are no enqueued skbs */
113 bool empty;
114 struct rcu_head rcu;
115 };
116
117 static 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 /* Intended to be used by unlocked users, when concurrent qdisc release is
125 * possible.
126 */
127
128 static 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
137 static 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
144 static inline bool qdisc_is_percpu_stats(const struct Qdisc *q)
145 {
146 return q->flags & TCQ_F_CPUSTATS;
147 }
148
149 static 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
156 static 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 /* Variant of write_seqcount_begin() telling lockdep a trylock
166 * was attempted.
167 */
168 raw_write_seqcount_begin(&qdisc->running);
169 seqcount_acquire(&qdisc->running.dep_map, 0, 1, _RET_IP_);
170 return true;
171 }
172
173 static 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
180 static inline bool qdisc_may_bulk(const struct Qdisc *qdisc)
181 {
182 return qdisc->flags & TCQ_F_ONETXQUEUE;
183 }
184
185 static inline int qdisc_avail_bulklimit(const struct netdev_queue *txq)
186 {
187 #ifdef CONFIG_BQL
188 /* Non-BQL migrated drivers will return 0, too. */
189 return dql_avail(&txq->dql);
190 #else
191 return 0;
192 #endif
193 }
194
195 struct Qdisc_class_ops {
196 unsigned int flags;
197 /* Child qdisc manipulation */
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 /* Class manipulation routines */
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 /* Filter manipulation */
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 /* rtnetlink specific */
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 /* Qdisc_class_ops flag values */
229
230 /* Implements API that doesn't require rtnl lock */
231 enum qdisc_class_ops_flags {
232 QDISC_CLASS_OPS_DOIT_UNLOCKED = 1,
233 };
234
235 struct 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
272 struct tcf_result {
273 union {
274 struct {
275 unsigned long class;
276 u32 classid;
277 };
278 const struct tcf_proto *goto_tp;
279
280 /* used in the skb_tc_reinsert function */
281 struct {
282 bool ingress;
283 struct gnet_stats_queue *qstats;
284 };
285 };
286 };
287
288 struct tcf_chain;
289
290 struct 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 /* rtnetlink specific */
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
335 enum tcf_proto_ops_flags {
336 TCF_PROTO_OPS_DOIT_UNLOCKED = 1,
337 };
338
339 struct tcf_proto {
340 /* Fast access part */
341 struct tcf_proto __rcu *next;
342 void __rcu *root;
343
344 /* called under RCU BH lock*/
345 int (*classify)(struct sk_buff *,
346 const struct tcf_proto *,
347 struct tcf_result *);
348 __be16 protocol;
349
350 /* All the rest */
351 u32 prio;
352 void *data;
353 const struct tcf_proto_ops *ops;
354 struct tcf_chain *chain;
355 /* Lock protects tcf_proto shared state and can be used by unlocked
356 * classifiers to protect their private data.
357 */
358 spinlock_t lock;
359 bool deleting;
360 refcount_t refcnt;
361 struct rcu_head rcu;
362 };
363
364 struct 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
374 typedef void tcf_chain_head_change_t(struct tcf_proto *tp_head, void *priv);
375
376 struct tcf_chain {
377 /* Protects filter_chain. */
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; /* chain 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
392 struct tcf_block {
393 /* Lock protects tcf_block and lifetime-management data of chains
394 * attached to the block (refcnt, action_refcnt, explicitly_created).
395 */
396 struct mutex lock;
397 struct list_head chain_list;
398 u32 index; /* block index for shared blocks */
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; /* Number of oddloaded filters */
406 unsigned int nooffloaddevcnt; /* Number of devs unable to do offload */
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
415 static inline bool lockdep_tcf_chain_is_locked(struct tcf_chain *chain)
416 {
417 return lockdep_is_held(&chain->filter_chain_lock);
418 }
419
420 static inline bool lockdep_tcf_proto_is_locked(struct tcf_proto *tp)
421 {
422 return lockdep_is_held(&tp->lock);
423 }
424 #else
425 static inline bool lockdep_tcf_chain_is_locked(struct tcf_block *chain)
426 {
427 return true;
428 }
429
430 static inline bool lockdep_tcf_proto_is_locked(struct tcf_proto *tp)
431 {
432 return true;
433 }
434 #endif /* #ifdef CONFIG_PROVE_LOCKING */
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
442 static 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
450 static 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
458 static inline void
459 tc_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
473 static 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
481 static inline int qdisc_qlen_cpu(const struct Qdisc *q)
482 {
483 return this_cpu_ptr(q->cpu_qstats)->qlen;
484 }
485
486 static inline int qdisc_qlen(const struct Qdisc *q)
487 {
488 return q->q.qlen;
489 }
490
491 static 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
506 static inline struct qdisc_skb_cb *qdisc_skb_cb(const struct sk_buff *skb)
507 {
508 return (struct qdisc_skb_cb *)skb->cb;
509 }
510
511 static inline spinlock_t *qdisc_lock(struct Qdisc *qdisc)
512 {
513 return &qdisc->q.lock;
514 }
515
516 static 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
523 static inline struct Qdisc *qdisc_root_sleeping(const struct Qdisc *qdisc)
524 {
525 return qdisc->dev_queue->qdisc_sleeping;
526 }
527
528 /* The qdisc root lock is a mechanism by which to top level
529 * of a qdisc tree can be locked from any qdisc node in the
530 * forest. This allows changing the configuration of some
531 * aspect of the qdisc tree while blocking out asynchronous
532 * qdisc access in the packet processing paths.
533 *
534 * It is only legal to do this when the root will not change
535 * on us. Otherwise we'll potentially lock the wrong qdisc
536 * root. This is enforced by holding the RTNL semaphore, which
537 * all users of this lock accessor must do.
538 */
539 static 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
547 static 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
555 static 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
563 static inline struct net_device *qdisc_dev(const struct Qdisc *qdisc)
564 {
565 return qdisc->dev_queue->dev;
566 }
567
568 static inline void sch_tree_lock(const struct Qdisc *q)
569 {
570 spin_lock_bh(qdisc_root_sleeping_lock(q));
571 }
572
573 static inline void sch_tree_unlock(const struct Qdisc *q)
574 {
575 spin_unlock_bh(qdisc_root_sleeping_lock(q));
576 }
577
578 extern struct Qdisc noop_qdisc;
579 extern struct Qdisc_ops noop_qdisc_ops;
580 extern struct Qdisc_ops pfifo_fast_ops;
581 extern struct Qdisc_ops mq_qdisc_ops;
582 extern struct Qdisc_ops noqueue_qdisc_ops;
583 extern const struct Qdisc_ops *default_qdisc_ops;
584 static inline const struct Qdisc_ops *
585 get_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
591 struct Qdisc_class_common {
592 u32 classid;
593 struct hlist_node hnode;
594 };
595
596 struct Qdisc_class_hash {
597 struct hlist_head *hash;
598 unsigned int hashsize;
599 unsigned int hashmask;
600 unsigned int hashelems;
601 };
602
603 static 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
610 static inline struct Qdisc_class_common *
611 qdisc_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
627 static 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
634 int qdisc_class_hash_init(struct Qdisc_class_hash *);
635 void qdisc_class_hash_insert(struct Qdisc_class_hash *,
636 struct Qdisc_class_common *);
637 void qdisc_class_hash_remove(struct Qdisc_class_hash *,
638 struct Qdisc_class_common *);
639 void qdisc_class_hash_grow(struct Qdisc *, struct Qdisc_class_hash *);
640 void qdisc_class_hash_destroy(struct Qdisc_class_hash *);
641
642 int dev_qdisc_change_tx_queue_len(struct net_device *dev);
643 void dev_init_scheduler(struct net_device *dev);
644 void dev_shutdown(struct net_device *dev);
645 void dev_activate(struct net_device *dev);
646 void dev_deactivate(struct net_device *dev);
647 void dev_deactivate_many(struct list_head *head);
648 struct Qdisc *dev_graft_qdisc(struct netdev_queue *dev_queue,
649 struct Qdisc *qdisc);
650 void qdisc_reset(struct Qdisc *qdisc);
651 void qdisc_put(struct Qdisc *qdisc);
652 void qdisc_put_unlocked(struct Qdisc *qdisc);
653 void qdisc_tree_reduce_backlog(struct Qdisc *qdisc, int n, int len);
654 #ifdef CONFIG_NET_SCHED
655 int qdisc_offload_dump_helper(struct Qdisc *q, enum tc_setup_type type,
656 void *type_data);
657 void 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
662 static inline int
663 qdisc_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
670 static inline void
671 qdisc_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
678 struct Qdisc *qdisc_alloc(struct netdev_queue *dev_queue,
679 const struct Qdisc_ops *ops,
680 struct netlink_ext_ack *extack);
681 void qdisc_free(struct Qdisc *qdisc);
682 struct Qdisc *qdisc_create_dflt(struct netdev_queue *dev_queue,
683 const struct Qdisc_ops *ops, u32 parentid,
684 struct netlink_ext_ack *extack);
685 void __qdisc_calculate_pkt_len(struct sk_buff *skb,
686 const struct qdisc_size_table *stab);
687 int skb_do_redirect(struct sk_buff *);
688
689 static 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
696 static 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
705 static 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
714 static 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 /* Reset all TX qdiscs greater than index of a device. */
726 static 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
740 static inline void qdisc_reset_all_tx(struct net_device *dev)
741 {
742 qdisc_reset_all_tx_gt(dev, 0);
743 }
744
745 /* Are all TX queues of the device empty? */
746 static 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 /* Are any of the TX qdiscs changing? */
765 static 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 /* Is the device using the noop qdisc on all queues? */
778 static 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
790 static inline unsigned int qdisc_pkt_len(const struct sk_buff *skb)
791 {
792 return qdisc_skb_cb(skb)->pkt_len;
793 }
794
795 /* additional qdisc xmit flags (NET_XMIT_MASK in linux/netdevice.h) */
796 enum 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
807 static 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
818 static 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
825 static 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
832 static 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
840 static 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
848 static 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
856 static 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
862 static inline void qdisc_bstats_update(struct Qdisc *sch,
863 const struct sk_buff *skb)
864 {
865 bstats_update(&sch->bstats, skb);
866 }
867
868 static 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
874 static 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
880 static 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
886 static 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
892 static inline void qdisc_qstats_cpu_qlen_inc(struct Qdisc *sch)
893 {
894 this_cpu_inc(sch->cpu_qstats->qlen);
895 }
896
897 static inline void qdisc_qstats_cpu_qlen_dec(struct Qdisc *sch)
898 {
899 this_cpu_dec(sch->cpu_qstats->qlen);
900 }
901
902 static inline void qdisc_qstats_cpu_requeues_inc(struct Qdisc *sch)
903 {
904 this_cpu_inc(sch->cpu_qstats->requeues);
905 }
906
907 static inline void __qdisc_qstats_drop(struct Qdisc *sch, int count)
908 {
909 sch->qstats.drops += count;
910 }
911
912 static inline void qstats_drop_inc(struct gnet_stats_queue *qstats)
913 {
914 qstats->drops++;
915 }
916
917 static inline void qstats_overlimit_inc(struct gnet_stats_queue *qstats)
918 {
919 qstats->overlimits++;
920 }
921
922 static inline void qdisc_qstats_drop(struct Qdisc *sch)
923 {
924 qstats_drop_inc(&sch->qstats);
925 }
926
927 static inline void qdisc_qstats_cpu_drop(struct Qdisc *sch)
928 {
929 this_cpu_inc(sch->cpu_qstats->drops);
930 }
931
932 static inline void qdisc_qstats_overlimit(struct Qdisc *sch)
933 {
934 sch->qstats.overlimits++;
935 }
936
937 static 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
944 static 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
955 static 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
963 static 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
972 static 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
979 static 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
995 static 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
1002 static 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
1013 static 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
1028 static 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 /* Instead of calling kfree_skb() while root qdisc lock is held,
1041 * queue the skb for future freeing at end of __dev_xmit_skb()
1042 */
1043 static 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
1049 static 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
1059 static 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
1076 static 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
1082 static 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 /* generic pseudo peek method for non-work-conserving qdisc */
1090 static inline struct sk_buff *qdisc_peek_dequeued(struct Qdisc *sch)
1091 {
1092 struct sk_buff *skb = skb_peek(&sch->gso_skb);
1093
1094 /* we can reuse ->gso_skb because peek isn't called for root qdiscs */
1095 if (!skb) {
1096 skb = sch->dequeue(sch);
1097
1098 if (skb) {
1099 __skb_queue_head(&sch->gso_skb, skb);
1100 /* it's still part of the queue */
1101 qdisc_qstats_backlog_inc(sch, skb);
1102 sch->q.qlen++;
1103 }
1104 }
1105
1106 return skb;
1107 }
1108
1109 static 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
1123 static 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 /* use instead of qdisc->dequeue() for all qdiscs queried with ->peek() */
1136 static 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
1156 static inline void __qdisc_reset_queue(struct qdisc_skb_head *qh)
1157 {
1158 /*
1159 * We do not know the backlog in bytes of this list, it
1160 * is up to the caller to correct it
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
1172 static inline void qdisc_reset_queue(struct Qdisc *sch)
1173 {
1174 __qdisc_reset_queue(&sch->q);
1175 sch->qstats.backlog = 0;
1176 }
1177
1178 static 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
1193 static 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
1199 static 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
1208 static 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
1217 static 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 /* Length to Time (L2T) lookup in a qdisc_rate_table, to determine how
1227 long it will take to send a packet given its size.
1228 */
1229 static 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
1240 struct psched_ratecfg {
1241 u64 rate_bytes_ps; /* bytes per second */
1242 u32 mult;
1243 u16 overhead;
1244 u8 linklayer;
1245 u8 shift;
1246 };
1247
1248 static 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
1259 void psched_ratecfg_precompute(struct psched_ratecfg *r,
1260 const struct tc_ratespec *conf,
1261 u64 rate64);
1262
1263 static inline void psched_ratecfg_getrate(struct tc_ratespec *res,
1264 const struct psched_ratecfg *r)
1265 {
1266 memset(res, 0, sizeof(*res));
1267
1268 /* legacy struct tc_ratespec has a 32bit @rate field
1269 * Qdisc using 64bit rate should add new attributes
1270 * in order to maintain compatibility.
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 /* Mini Qdisc serves for specific needs of ingress/clsact Qdisc.
1279 * The fast path only needs to access filter list and to update stats
1280 */
1281 struct 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
1288 static 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
1294 static inline void mini_qdisc_qstats_cpu_drop(struct mini_Qdisc *miniq)
1295 {
1296 this_cpu_inc(miniq->cpu_qstats->drops);
1297 }
1298
1299 struct mini_Qdisc_pair {
1300 struct mini_Qdisc miniq1;
1301 struct mini_Qdisc miniq2;
1302 struct mini_Qdisc __rcu **p_miniq;
1303 };
1304
1305 void mini_qdisc_pair_swap(struct mini_Qdisc_pair *miniqp,
1306 struct tcf_proto *tp_head);
1307 void mini_qdisc_pair_init(struct mini_Qdisc_pair *miniqp, struct Qdisc *qdisc,
1308 struct mini_Qdisc __rcu **p_miniq);
1309
1310 static 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
Linux with added FPC-III support