Branch data Line data Source code
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 <linux/rwsem.h>
17 : : #include <linux/atomic.h>
18 : : #include <linux/hashtable.h>
19 : : #include <net/gen_stats.h>
20 : : #include <net/rtnetlink.h>
21 : : #include <net/flow_offload.h>
22 : :
23 : : struct Qdisc_ops;
24 : : struct qdisc_walker;
25 : : struct tcf_walker;
26 : : struct module;
27 : : struct bpf_flow_keys;
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 [ + - # # : 621 : if (qdisc->flags & TCQ_F_BUILTIN)
# # ]
120 : : return;
121 : 621 : refcount_inc(&qdisc->refcnt);
122 : : }
123 : :
124 : : /* Intended to be used by unlocked users, when concurrent qdisc release is
125 : : * possible.
126 : : */
127 : :
128 : 0 : static inline struct Qdisc *qdisc_refcount_inc_nz(struct Qdisc *qdisc)
129 : : {
130 [ # # ]: 0 : if (qdisc->flags & TCQ_F_BUILTIN)
131 : : return qdisc;
132 [ # # ]: 0 : if (refcount_inc_not_zero(&qdisc->refcnt))
133 : 0 : return qdisc;
134 : : return NULL;
135 : : }
136 : :
137 : 1298 : static inline bool qdisc_is_running(struct Qdisc *qdisc)
138 : : {
139 [ + + ]: 1298 : if (qdisc->flags & TCQ_F_NOLOCK)
140 : 207 : return spin_is_locked(&qdisc->seqlock);
141 : 1091 : 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 : 20704 : 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 READ_ONCE(qdisc->empty);
153 : : return !READ_ONCE(qdisc->q.qlen);
154 : : }
155 : :
156 : 15117 : static inline bool qdisc_run_begin(struct Qdisc *qdisc)
157 : : {
158 [ + + ]: 15117 : if (qdisc->flags & TCQ_F_NOLOCK) {
159 [ + + ]: 14468 : if (!spin_trylock(&qdisc->seqlock))
160 : : return false;
161 : : WRITE_ONCE(qdisc->empty, false);
162 [ + - ]: 649 : } 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 : 15113 : return true;
171 : : }
172 : :
173 : 15113 : static inline void qdisc_run_end(struct Qdisc *qdisc)
174 : : {
175 : : write_seqcount_end(&qdisc->running);
176 [ + + ]: 15113 : if (qdisc->flags & TCQ_F_NOLOCK)
177 : : spin_unlock(&qdisc->seqlock);
178 : 15113 : }
179 : :
180 : : static inline bool qdisc_may_bulk(const struct Qdisc *qdisc)
181 : : {
182 : 10145 : 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 : : bool (*delete_empty)(struct tcf_proto *tp);
312 : : void (*walk)(struct tcf_proto *tp,
313 : : struct tcf_walker *arg, bool rtnl_held);
314 : : int (*reoffload)(struct tcf_proto *tp, bool add,
315 : : flow_setup_cb_t *cb, void *cb_priv,
316 : : struct netlink_ext_ack *extack);
317 : : void (*hw_add)(struct tcf_proto *tp,
318 : : void *type_data);
319 : : void (*hw_del)(struct tcf_proto *tp,
320 : : void *type_data);
321 : : void (*bind_class)(void *, u32, unsigned long,
322 : : void *, unsigned long);
323 : : void * (*tmplt_create)(struct net *net,
324 : : struct tcf_chain *chain,
325 : : struct nlattr **tca,
326 : : struct netlink_ext_ack *extack);
327 : : void (*tmplt_destroy)(void *tmplt_priv);
328 : :
329 : : /* rtnetlink specific */
330 : : int (*dump)(struct net*, struct tcf_proto*, void *,
331 : : struct sk_buff *skb, struct tcmsg*,
332 : : bool);
333 : : int (*tmplt_dump)(struct sk_buff *skb,
334 : : struct net *net,
335 : : void *tmplt_priv);
336 : :
337 : : struct module *owner;
338 : : int flags;
339 : : };
340 : :
341 : : /* Classifiers setting TCF_PROTO_OPS_DOIT_UNLOCKED in tcf_proto_ops->flags
342 : : * are expected to implement tcf_proto_ops->delete_empty(), otherwise race
343 : : * conditions can occur when filters are inserted/deleted simultaneously.
344 : : */
345 : : enum tcf_proto_ops_flags {
346 : : TCF_PROTO_OPS_DOIT_UNLOCKED = 1,
347 : : };
348 : :
349 : : struct tcf_proto {
350 : : /* Fast access part */
351 : : struct tcf_proto __rcu *next;
352 : : void __rcu *root;
353 : :
354 : : /* called under RCU BH lock*/
355 : : int (*classify)(struct sk_buff *,
356 : : const struct tcf_proto *,
357 : : struct tcf_result *);
358 : : __be16 protocol;
359 : :
360 : : /* All the rest */
361 : : u32 prio;
362 : : void *data;
363 : : const struct tcf_proto_ops *ops;
364 : : struct tcf_chain *chain;
365 : : /* Lock protects tcf_proto shared state and can be used by unlocked
366 : : * classifiers to protect their private data.
367 : : */
368 : : spinlock_t lock;
369 : : bool deleting;
370 : : refcount_t refcnt;
371 : : struct rcu_head rcu;
372 : : struct hlist_node destroy_ht_node;
373 : : };
374 : :
375 : : struct qdisc_skb_cb {
376 : : struct {
377 : : unsigned int pkt_len;
378 : : u16 slave_dev_queue_mapping;
379 : : u16 tc_classid;
380 : : };
381 : : #define QDISC_CB_PRIV_LEN 20
382 : : unsigned char data[QDISC_CB_PRIV_LEN];
383 : : };
384 : :
385 : : typedef void tcf_chain_head_change_t(struct tcf_proto *tp_head, void *priv);
386 : :
387 : : struct tcf_chain {
388 : : /* Protects filter_chain. */
389 : : struct mutex filter_chain_lock;
390 : : struct tcf_proto __rcu *filter_chain;
391 : : struct list_head list;
392 : : struct tcf_block *block;
393 : : u32 index; /* chain index */
394 : : unsigned int refcnt;
395 : : unsigned int action_refcnt;
396 : : bool explicitly_created;
397 : : bool flushing;
398 : : const struct tcf_proto_ops *tmplt_ops;
399 : : void *tmplt_priv;
400 : : struct rcu_head rcu;
401 : : };
402 : :
403 : : struct tcf_block {
404 : : /* Lock protects tcf_block and lifetime-management data of chains
405 : : * attached to the block (refcnt, action_refcnt, explicitly_created).
406 : : */
407 : : struct mutex lock;
408 : : struct list_head chain_list;
409 : : u32 index; /* block index for shared blocks */
410 : : u32 classid; /* which class this block belongs to */
411 : : refcount_t refcnt;
412 : : struct net *net;
413 : : struct Qdisc *q;
414 : : struct rw_semaphore cb_lock; /* protects cb_list and offload counters */
415 : : struct flow_block flow_block;
416 : : struct list_head owner_list;
417 : : bool keep_dst;
418 : : atomic_t offloadcnt; /* Number of oddloaded filters */
419 : : unsigned int nooffloaddevcnt; /* Number of devs unable to do offload */
420 : : unsigned int lockeddevcnt; /* Number of devs that require rtnl lock. */
421 : : struct {
422 : : struct tcf_chain *chain;
423 : : struct list_head filter_chain_list;
424 : : } chain0;
425 : : struct rcu_head rcu;
426 : : DECLARE_HASHTABLE(proto_destroy_ht, 7);
427 : : struct mutex proto_destroy_lock; /* Lock for proto_destroy hashtable. */
428 : : };
429 : :
430 : : #ifdef CONFIG_PROVE_LOCKING
431 : : static inline bool lockdep_tcf_chain_is_locked(struct tcf_chain *chain)
432 : : {
433 : : return lockdep_is_held(&chain->filter_chain_lock);
434 : : }
435 : :
436 : : static inline bool lockdep_tcf_proto_is_locked(struct tcf_proto *tp)
437 : : {
438 : : return lockdep_is_held(&tp->lock);
439 : : }
440 : : #else
441 : : static inline bool lockdep_tcf_chain_is_locked(struct tcf_block *chain)
442 : : {
443 : : return true;
444 : : }
445 : :
446 : : static inline bool lockdep_tcf_proto_is_locked(struct tcf_proto *tp)
447 : : {
448 : : return true;
449 : : }
450 : : #endif /* #ifdef CONFIG_PROVE_LOCKING */
451 : :
452 : : #define tcf_chain_dereference(p, chain) \
453 : : rcu_dereference_protected(p, lockdep_tcf_chain_is_locked(chain))
454 : :
455 : : #define tcf_proto_dereference(p, tp) \
456 : : rcu_dereference_protected(p, lockdep_tcf_proto_is_locked(tp))
457 : :
458 : : static inline void qdisc_cb_private_validate(const struct sk_buff *skb, int sz)
459 : : {
460 : : struct qdisc_skb_cb *qcb;
461 : :
462 : : BUILD_BUG_ON(sizeof(skb->cb) < offsetof(struct qdisc_skb_cb, data) + sz);
463 : : BUILD_BUG_ON(sizeof(qcb->data) < sz);
464 : : }
465 : :
466 : : static inline int qdisc_qlen_cpu(const struct Qdisc *q)
467 : : {
468 : : return this_cpu_ptr(q->cpu_qstats)->qlen;
469 : : }
470 : :
471 : : static inline int qdisc_qlen(const struct Qdisc *q)
472 : : {
473 : 0 : return q->q.qlen;
474 : : }
475 : :
476 : 0 : static inline int qdisc_qlen_sum(const struct Qdisc *q)
477 : : {
478 : 0 : __u32 qlen = q->qstats.qlen;
479 : : int i;
480 : :
481 [ # # ]: 0 : if (qdisc_is_percpu_stats(q)) {
482 [ # # ]: 0 : for_each_possible_cpu(i)
483 : 0 : qlen += per_cpu_ptr(q->cpu_qstats, i)->qlen;
484 : : } else {
485 : 0 : qlen += q->q.qlen;
486 : : }
487 : :
488 : 0 : return qlen;
489 : : }
490 : :
491 : : static inline struct qdisc_skb_cb *qdisc_skb_cb(const struct sk_buff *skb)
492 : : {
493 : : return (struct qdisc_skb_cb *)skb->cb;
494 : : }
495 : :
496 : : static inline spinlock_t *qdisc_lock(struct Qdisc *qdisc)
497 : : {
498 : 10783 : return &qdisc->q.lock;
499 : : }
500 : :
501 : : static inline struct Qdisc *qdisc_root(const struct Qdisc *qdisc)
502 : : {
503 : 0 : struct Qdisc *q = rcu_dereference_rtnl(qdisc->dev_queue->qdisc);
504 : :
505 : : return q;
506 : : }
507 : :
508 : : static inline struct Qdisc *qdisc_root_bh(const struct Qdisc *qdisc)
509 : : {
510 : : return rcu_dereference_bh(qdisc->dev_queue->qdisc);
511 : : }
512 : :
513 : : static inline struct Qdisc *qdisc_root_sleeping(const struct Qdisc *qdisc)
514 : : {
515 : 0 : return qdisc->dev_queue->qdisc_sleeping;
516 : : }
517 : :
518 : : /* The qdisc root lock is a mechanism by which to top level
519 : : * of a qdisc tree can be locked from any qdisc node in the
520 : : * forest. This allows changing the configuration of some
521 : : * aspect of the qdisc tree while blocking out asynchronous
522 : : * qdisc access in the packet processing paths.
523 : : *
524 : : * It is only legal to do this when the root will not change
525 : : * on us. Otherwise we'll potentially lock the wrong qdisc
526 : : * root. This is enforced by holding the RTNL semaphore, which
527 : : * all users of this lock accessor must do.
528 : : */
529 : : static inline spinlock_t *qdisc_root_lock(const struct Qdisc *qdisc)
530 : : {
531 : : struct Qdisc *root = qdisc_root(qdisc);
532 : :
533 : : ASSERT_RTNL();
534 : : return qdisc_lock(root);
535 : : }
536 : :
537 : 0 : static inline spinlock_t *qdisc_root_sleeping_lock(const struct Qdisc *qdisc)
538 : : {
539 : : struct Qdisc *root = qdisc_root_sleeping(qdisc);
540 : :
541 [ # # # # ]: 0 : ASSERT_RTNL();
542 : 0 : return qdisc_lock(root);
543 : : }
544 : :
545 : 0 : static inline seqcount_t *qdisc_root_sleeping_running(const struct Qdisc *qdisc)
546 : : {
547 : : struct Qdisc *root = qdisc_root_sleeping(qdisc);
548 : :
549 [ # # # # ]: 0 : ASSERT_RTNL();
550 : 0 : return &root->running;
551 : : }
552 : :
553 : : static inline struct net_device *qdisc_dev(const struct Qdisc *qdisc)
554 : : {
555 : 10352 : return qdisc->dev_queue->dev;
556 : : }
557 : :
558 : : static inline void sch_tree_lock(const struct Qdisc *q)
559 : : {
560 : 0 : spin_lock_bh(qdisc_root_sleeping_lock(q));
561 : : }
562 : :
563 : : static inline void sch_tree_unlock(const struct Qdisc *q)
564 : : {
565 : 0 : spin_unlock_bh(qdisc_root_sleeping_lock(q));
566 : : }
567 : :
568 : : extern struct Qdisc noop_qdisc;
569 : : extern struct Qdisc_ops noop_qdisc_ops;
570 : : extern struct Qdisc_ops pfifo_fast_ops;
571 : : extern struct Qdisc_ops mq_qdisc_ops;
572 : : extern struct Qdisc_ops noqueue_qdisc_ops;
573 : : extern const struct Qdisc_ops *default_qdisc_ops;
574 : : static inline const struct Qdisc_ops *
575 : : get_default_qdisc_ops(const struct net_device *dev, int ntx)
576 : : {
577 : 0 : return ntx < dev->real_num_tx_queues ?
578 [ # # ]: 0 : default_qdisc_ops : &pfifo_fast_ops;
579 : : }
580 : :
581 : : struct Qdisc_class_common {
582 : : u32 classid;
583 : : struct hlist_node hnode;
584 : : };
585 : :
586 : : struct Qdisc_class_hash {
587 : : struct hlist_head *hash;
588 : : unsigned int hashsize;
589 : : unsigned int hashmask;
590 : : unsigned int hashelems;
591 : : };
592 : :
593 : : static inline unsigned int qdisc_class_hash(u32 id, u32 mask)
594 : : {
595 : 0 : id ^= id >> 8;
596 : 0 : id ^= id >> 4;
597 : 0 : return id & mask;
598 : : }
599 : :
600 : : static inline struct Qdisc_class_common *
601 : : qdisc_class_find(const struct Qdisc_class_hash *hash, u32 id)
602 : : {
603 : : struct Qdisc_class_common *cl;
604 : : unsigned int h;
605 : :
606 : : if (!id)
607 : : return NULL;
608 : :
609 : : h = qdisc_class_hash(id, hash->hashmask);
610 : : hlist_for_each_entry(cl, &hash->hash[h], hnode) {
611 : : if (cl->classid == id)
612 : : return cl;
613 : : }
614 : : return NULL;
615 : : }
616 : :
617 : : static inline int tc_classid_to_hwtc(struct net_device *dev, u32 classid)
618 : : {
619 : : u32 hwtc = TC_H_MIN(classid) - TC_H_MIN_PRIORITY;
620 : :
621 : : return (hwtc < netdev_get_num_tc(dev)) ? hwtc : -EINVAL;
622 : : }
623 : :
624 : : int qdisc_class_hash_init(struct Qdisc_class_hash *);
625 : : void qdisc_class_hash_insert(struct Qdisc_class_hash *,
626 : : struct Qdisc_class_common *);
627 : : void qdisc_class_hash_remove(struct Qdisc_class_hash *,
628 : : struct Qdisc_class_common *);
629 : : void qdisc_class_hash_grow(struct Qdisc *, struct Qdisc_class_hash *);
630 : : void qdisc_class_hash_destroy(struct Qdisc_class_hash *);
631 : :
632 : : int dev_qdisc_change_tx_queue_len(struct net_device *dev);
633 : : void dev_init_scheduler(struct net_device *dev);
634 : : void dev_shutdown(struct net_device *dev);
635 : : void dev_activate(struct net_device *dev);
636 : : void dev_deactivate(struct net_device *dev);
637 : : void dev_deactivate_many(struct list_head *head);
638 : : struct Qdisc *dev_graft_qdisc(struct netdev_queue *dev_queue,
639 : : struct Qdisc *qdisc);
640 : : void qdisc_reset(struct Qdisc *qdisc);
641 : : void qdisc_put(struct Qdisc *qdisc);
642 : : void qdisc_put_unlocked(struct Qdisc *qdisc);
643 : : void qdisc_tree_reduce_backlog(struct Qdisc *qdisc, int n, int len);
644 : : #ifdef CONFIG_NET_SCHED
645 : : int qdisc_offload_dump_helper(struct Qdisc *q, enum tc_setup_type type,
646 : : void *type_data);
647 : : void qdisc_offload_graft_helper(struct net_device *dev, struct Qdisc *sch,
648 : : struct Qdisc *new, struct Qdisc *old,
649 : : enum tc_setup_type type, void *type_data,
650 : : struct netlink_ext_ack *extack);
651 : : #else
652 : : static inline int
653 : : qdisc_offload_dump_helper(struct Qdisc *q, enum tc_setup_type type,
654 : : void *type_data)
655 : : {
656 : : q->flags &= ~TCQ_F_OFFLOADED;
657 : : return 0;
658 : : }
659 : :
660 : : static inline void
661 : : qdisc_offload_graft_helper(struct net_device *dev, struct Qdisc *sch,
662 : : struct Qdisc *new, struct Qdisc *old,
663 : : enum tc_setup_type type, void *type_data,
664 : : struct netlink_ext_ack *extack)
665 : : {
666 : : }
667 : : #endif
668 : : struct Qdisc *qdisc_alloc(struct netdev_queue *dev_queue,
669 : : const struct Qdisc_ops *ops,
670 : : struct netlink_ext_ack *extack);
671 : : void qdisc_free(struct Qdisc *qdisc);
672 : : struct Qdisc *qdisc_create_dflt(struct netdev_queue *dev_queue,
673 : : const struct Qdisc_ops *ops, u32 parentid,
674 : : struct netlink_ext_ack *extack);
675 : : void __qdisc_calculate_pkt_len(struct sk_buff *skb,
676 : : const struct qdisc_size_table *stab);
677 : : int skb_do_redirect(struct sk_buff *);
678 : :
679 : : static inline bool skb_at_tc_ingress(const struct sk_buff *skb)
680 : : {
681 : : #ifdef CONFIG_NET_CLS_ACT
682 : 0 : return skb->tc_at_ingress;
683 : : #else
684 : : return false;
685 : : #endif
686 : : }
687 : :
688 : : static inline bool skb_skip_tc_classify(struct sk_buff *skb)
689 : : {
690 : : #ifdef CONFIG_NET_CLS_ACT
691 [ - + ]: 10085 : if (skb->tc_skip_classify) {
692 : 0 : skb->tc_skip_classify = 0;
693 : : return true;
694 : : }
695 : : #endif
696 : : return false;
697 : : }
698 : :
699 : : /* Reset all TX qdiscs greater than index of a device. */
700 : 0 : static inline void qdisc_reset_all_tx_gt(struct net_device *dev, unsigned int i)
701 : : {
702 : : struct Qdisc *qdisc;
703 : :
704 [ # # ]: 0 : for (; i < dev->num_tx_queues; i++) {
705 : 0 : qdisc = rtnl_dereference(netdev_get_tx_queue(dev, i)->qdisc);
706 [ # # ]: 0 : if (qdisc) {
707 : : spin_lock_bh(qdisc_lock(qdisc));
708 : 0 : qdisc_reset(qdisc);
709 : : spin_unlock_bh(qdisc_lock(qdisc));
710 : : }
711 : : }
712 : 0 : }
713 : :
714 : : static inline void qdisc_reset_all_tx(struct net_device *dev)
715 : : {
716 : : qdisc_reset_all_tx_gt(dev, 0);
717 : : }
718 : :
719 : : /* Are all TX queues of the device empty? */
720 : : static inline bool qdisc_all_tx_empty(const struct net_device *dev)
721 : : {
722 : : unsigned int i;
723 : :
724 : : rcu_read_lock();
725 : : for (i = 0; i < dev->num_tx_queues; i++) {
726 : : struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
727 : : const struct Qdisc *q = rcu_dereference(txq->qdisc);
728 : :
729 : : if (!qdisc_is_empty(q)) {
730 : : rcu_read_unlock();
731 : : return false;
732 : : }
733 : : }
734 : : rcu_read_unlock();
735 : : return true;
736 : : }
737 : :
738 : : /* Are any of the TX qdiscs changing? */
739 : : static inline bool qdisc_tx_changing(const struct net_device *dev)
740 : : {
741 : : unsigned int i;
742 : :
743 [ + - ]: 0 : for (i = 0; i < dev->num_tx_queues; i++) {
744 : : struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
745 [ - + ]: 259 : if (rcu_access_pointer(txq->qdisc) != txq->qdisc_sleeping)
746 : : return true;
747 : : }
748 : : return false;
749 : : }
750 : :
751 : : /* Is the device using the noop qdisc on all queues? */
752 : : static inline bool qdisc_tx_is_noop(const struct net_device *dev)
753 : : {
754 : : unsigned int i;
755 : :
756 [ + - ]: 0 : for (i = 0; i < dev->num_tx_queues; i++) {
757 : : struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
758 [ - + ]: 4996 : if (rcu_access_pointer(txq->qdisc) != &noop_qdisc)
759 : : return false;
760 : : }
761 : : return true;
762 : : }
763 : :
764 : : static inline unsigned int qdisc_pkt_len(const struct sk_buff *skb)
765 : : {
766 : 30435 : return qdisc_skb_cb(skb)->pkt_len;
767 : : }
768 : :
769 : : /* additional qdisc xmit flags (NET_XMIT_MASK in linux/netdevice.h) */
770 : : enum net_xmit_qdisc_t {
771 : : __NET_XMIT_STOLEN = 0x00010000,
772 : : __NET_XMIT_BYPASS = 0x00020000,
773 : : };
774 : :
775 : : #ifdef CONFIG_NET_CLS_ACT
776 : : #define net_xmit_drop_count(e) ((e) & __NET_XMIT_STOLEN ? 0 : 1)
777 : : #else
778 : : #define net_xmit_drop_count(e) (1)
779 : : #endif
780 : :
781 : : static inline void qdisc_calculate_pkt_len(struct sk_buff *skb,
782 : : const struct Qdisc *sch)
783 : : {
784 : : #ifdef CONFIG_NET_SCHED
785 : 10576 : struct qdisc_size_table *stab = rcu_dereference_bh(sch->stab);
786 : :
787 [ - + ]: 10576 : if (stab)
788 : 0 : __qdisc_calculate_pkt_len(skb, stab);
789 : : #endif
790 : : }
791 : :
792 : : static inline int qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch,
793 : : struct sk_buff **to_free)
794 : : {
795 : : qdisc_calculate_pkt_len(skb, sch);
796 : : return sch->enqueue(skb, sch, to_free);
797 : : }
798 : :
799 : : static inline void _bstats_update(struct gnet_stats_basic_packed *bstats,
800 : : __u64 bytes, __u32 packets)
801 : : {
802 : 10145 : bstats->bytes += bytes;
803 : 10145 : bstats->packets += packets;
804 : : }
805 : :
806 : : static inline void bstats_update(struct gnet_stats_basic_packed *bstats,
807 : : const struct sk_buff *skb)
808 : : {
809 [ # # - + ]: 20290 : _bstats_update(bstats,
810 : : qdisc_pkt_len(skb),
811 : 0 : skb_is_gso(skb) ? skb_shinfo(skb)->gso_segs : 1);
812 : : }
813 : :
814 : : static inline void _bstats_cpu_update(struct gnet_stats_basic_cpu *bstats,
815 : : __u64 bytes, __u32 packets)
816 : : {
817 : : u64_stats_update_begin(&bstats->syncp);
818 : : _bstats_update(&bstats->bstats, bytes, packets);
819 : : u64_stats_update_end(&bstats->syncp);
820 : : }
821 : :
822 : 10145 : static inline void bstats_cpu_update(struct gnet_stats_basic_cpu *bstats,
823 : : const struct sk_buff *skb)
824 : : {
825 : : u64_stats_update_begin(&bstats->syncp);
826 : : bstats_update(&bstats->bstats, skb);
827 : : u64_stats_update_end(&bstats->syncp);
828 : 10145 : }
829 : :
830 : : static inline void qdisc_bstats_cpu_update(struct Qdisc *sch,
831 : : const struct sk_buff *skb)
832 : : {
833 : 20290 : bstats_cpu_update(this_cpu_ptr(sch->cpu_bstats), skb);
834 : : }
835 : :
836 : : static inline void qdisc_bstats_update(struct Qdisc *sch,
837 : : const struct sk_buff *skb)
838 : : {
839 : : bstats_update(&sch->bstats, skb);
840 : : }
841 : :
842 : : static inline void qdisc_qstats_backlog_dec(struct Qdisc *sch,
843 : : const struct sk_buff *skb)
844 : : {
845 : 0 : sch->qstats.backlog -= qdisc_pkt_len(skb);
846 : : }
847 : :
848 : : static inline void qdisc_qstats_cpu_backlog_dec(struct Qdisc *sch,
849 : : const struct sk_buff *skb)
850 : : {
851 : 20290 : this_cpu_sub(sch->cpu_qstats->backlog, qdisc_pkt_len(skb));
852 : : }
853 : :
854 : : static inline void qdisc_qstats_backlog_inc(struct Qdisc *sch,
855 : : const struct sk_buff *skb)
856 : : {
857 : 0 : sch->qstats.backlog += qdisc_pkt_len(skb);
858 : : }
859 : :
860 : : static inline void qdisc_qstats_cpu_backlog_inc(struct Qdisc *sch,
861 : : const struct sk_buff *skb)
862 : : {
863 : 0 : this_cpu_add(sch->cpu_qstats->backlog, qdisc_pkt_len(skb));
864 : : }
865 : :
866 : 10145 : static inline void qdisc_qstats_cpu_qlen_inc(struct Qdisc *sch)
867 : : {
868 : 20290 : this_cpu_inc(sch->cpu_qstats->qlen);
869 : 10145 : }
870 : :
871 : 10145 : static inline void qdisc_qstats_cpu_qlen_dec(struct Qdisc *sch)
872 : : {
873 : 20290 : this_cpu_dec(sch->cpu_qstats->qlen);
874 : 10145 : }
875 : :
876 : 0 : static inline void qdisc_qstats_cpu_requeues_inc(struct Qdisc *sch)
877 : : {
878 : 0 : this_cpu_inc(sch->cpu_qstats->requeues);
879 : 0 : }
880 : :
881 : : static inline void __qdisc_qstats_drop(struct Qdisc *sch, int count)
882 : : {
883 : 0 : sch->qstats.drops += count;
884 : : }
885 : :
886 : : static inline void qstats_drop_inc(struct gnet_stats_queue *qstats)
887 : : {
888 : 0 : qstats->drops++;
889 : : }
890 : :
891 : : static inline void qstats_overlimit_inc(struct gnet_stats_queue *qstats)
892 : : {
893 : : qstats->overlimits++;
894 : : }
895 : :
896 : : static inline void qdisc_qstats_drop(struct Qdisc *sch)
897 : : {
898 : : qstats_drop_inc(&sch->qstats);
899 : : }
900 : :
901 : 0 : static inline void qdisc_qstats_cpu_drop(struct Qdisc *sch)
902 : : {
903 : 0 : this_cpu_inc(sch->cpu_qstats->drops);
904 : 0 : }
905 : :
906 : : static inline void qdisc_qstats_overlimit(struct Qdisc *sch)
907 : : {
908 : : sch->qstats.overlimits++;
909 : : }
910 : :
911 : 0 : static inline int qdisc_qstats_copy(struct gnet_dump *d, struct Qdisc *sch)
912 : : {
913 : 0 : __u32 qlen = qdisc_qlen_sum(sch);
914 : :
915 : 0 : return gnet_stats_copy_queue(d, sch->cpu_qstats, &sch->qstats, qlen);
916 : : }
917 : :
918 : : static inline void qdisc_qstats_qlen_backlog(struct Qdisc *sch, __u32 *qlen,
919 : : __u32 *backlog)
920 : : {
921 : : struct gnet_stats_queue qstats = { 0 };
922 : : __u32 len = qdisc_qlen_sum(sch);
923 : :
924 : : __gnet_stats_copy_queue(&qstats, sch->cpu_qstats, &sch->qstats, len);
925 : : *qlen = qstats.qlen;
926 : : *backlog = qstats.backlog;
927 : : }
928 : :
929 : : static inline void qdisc_tree_flush_backlog(struct Qdisc *sch)
930 : : {
931 : : __u32 qlen, backlog;
932 : :
933 : : qdisc_qstats_qlen_backlog(sch, &qlen, &backlog);
934 : : qdisc_tree_reduce_backlog(sch, qlen, backlog);
935 : : }
936 : :
937 : : static inline void qdisc_purge_queue(struct Qdisc *sch)
938 : : {
939 : : __u32 qlen, backlog;
940 : :
941 : : qdisc_qstats_qlen_backlog(sch, &qlen, &backlog);
942 : : qdisc_reset(sch);
943 : : qdisc_tree_reduce_backlog(sch, qlen, backlog);
944 : : }
945 : :
946 : : static inline void qdisc_skb_head_init(struct qdisc_skb_head *qh)
947 : : {
948 : 621 : qh->head = NULL;
949 : 621 : qh->tail = NULL;
950 : 621 : qh->qlen = 0;
951 : : }
952 : :
953 : : static inline void __qdisc_enqueue_tail(struct sk_buff *skb,
954 : : struct qdisc_skb_head *qh)
955 : : {
956 : 0 : struct sk_buff *last = qh->tail;
957 : :
958 [ # # # # : 0 : if (last) {
# # # # ]
959 : 0 : skb->next = NULL;
960 : 0 : last->next = skb;
961 : 0 : qh->tail = skb;
962 : : } else {
963 : 0 : qh->tail = skb;
964 : 0 : qh->head = skb;
965 : : }
966 : 0 : qh->qlen++;
967 : : }
968 : :
969 : : static inline int qdisc_enqueue_tail(struct sk_buff *skb, struct Qdisc *sch)
970 : : {
971 : : __qdisc_enqueue_tail(skb, &sch->q);
972 : : qdisc_qstats_backlog_inc(sch, skb);
973 : : return NET_XMIT_SUCCESS;
974 : : }
975 : :
976 : : static inline void __qdisc_enqueue_head(struct sk_buff *skb,
977 : : struct qdisc_skb_head *qh)
978 : : {
979 : : skb->next = qh->head;
980 : :
981 : : if (!qh->head)
982 : : qh->tail = skb;
983 : : qh->head = skb;
984 : : qh->qlen++;
985 : : }
986 : :
987 : : static inline struct sk_buff *__qdisc_dequeue_head(struct qdisc_skb_head *qh)
988 : : {
989 : 0 : struct sk_buff *skb = qh->head;
990 : :
991 [ # # # # ]: 0 : if (likely(skb != NULL)) {
992 : 0 : qh->head = skb->next;
993 : 0 : qh->qlen--;
994 [ # # # # ]: 0 : if (qh->head == NULL)
995 : 0 : qh->tail = NULL;
996 : 0 : skb->next = NULL;
997 : : }
998 : :
999 : : return skb;
1000 : : }
1001 : :
1002 : 0 : static inline struct sk_buff *qdisc_dequeue_head(struct Qdisc *sch)
1003 : : {
1004 : : struct sk_buff *skb = __qdisc_dequeue_head(&sch->q);
1005 : :
1006 [ # # ]: 0 : if (likely(skb != NULL)) {
1007 : : qdisc_qstats_backlog_dec(sch, skb);
1008 : : qdisc_bstats_update(sch, skb);
1009 : : }
1010 : :
1011 : 0 : return skb;
1012 : : }
1013 : :
1014 : : /* Instead of calling kfree_skb() while root qdisc lock is held,
1015 : : * queue the skb for future freeing at end of __dev_xmit_skb()
1016 : : */
1017 : : static inline void __qdisc_drop(struct sk_buff *skb, struct sk_buff **to_free)
1018 : : {
1019 : 442 : skb->next = *to_free;
1020 : 442 : *to_free = skb;
1021 : : }
1022 : :
1023 : : static inline void __qdisc_drop_all(struct sk_buff *skb,
1024 : : struct sk_buff **to_free)
1025 : : {
1026 : : if (skb->prev)
1027 : : skb->prev->next = *to_free;
1028 : : else
1029 : : skb->next = *to_free;
1030 : : *to_free = skb;
1031 : : }
1032 : :
1033 : 0 : static inline unsigned int __qdisc_queue_drop_head(struct Qdisc *sch,
1034 : : struct qdisc_skb_head *qh,
1035 : : struct sk_buff **to_free)
1036 : : {
1037 : : struct sk_buff *skb = __qdisc_dequeue_head(qh);
1038 : :
1039 [ # # ]: 0 : if (likely(skb != NULL)) {
1040 : : unsigned int len = qdisc_pkt_len(skb);
1041 : :
1042 : : qdisc_qstats_backlog_dec(sch, skb);
1043 : : __qdisc_drop(skb, to_free);
1044 : 0 : return len;
1045 : : }
1046 : :
1047 : : return 0;
1048 : : }
1049 : :
1050 : : static inline unsigned int qdisc_queue_drop_head(struct Qdisc *sch,
1051 : : struct sk_buff **to_free)
1052 : : {
1053 : : return __qdisc_queue_drop_head(sch, &sch->q, to_free);
1054 : : }
1055 : :
1056 : 0 : static inline struct sk_buff *qdisc_peek_head(struct Qdisc *sch)
1057 : : {
1058 : : const struct qdisc_skb_head *qh = &sch->q;
1059 : :
1060 : 0 : return qh->head;
1061 : : }
1062 : :
1063 : : /* generic pseudo peek method for non-work-conserving qdisc */
1064 : : static inline struct sk_buff *qdisc_peek_dequeued(struct Qdisc *sch)
1065 : : {
1066 : : struct sk_buff *skb = skb_peek(&sch->gso_skb);
1067 : :
1068 : : /* we can reuse ->gso_skb because peek isn't called for root qdiscs */
1069 : : if (!skb) {
1070 : : skb = sch->dequeue(sch);
1071 : :
1072 : : if (skb) {
1073 : : __skb_queue_head(&sch->gso_skb, skb);
1074 : : /* it's still part of the queue */
1075 : : qdisc_qstats_backlog_inc(sch, skb);
1076 : : sch->q.qlen++;
1077 : : }
1078 : : }
1079 : :
1080 : : return skb;
1081 : : }
1082 : :
1083 : 10145 : static inline void qdisc_update_stats_at_dequeue(struct Qdisc *sch,
1084 : : struct sk_buff *skb)
1085 : : {
1086 [ + - ]: 10145 : if (qdisc_is_percpu_stats(sch)) {
1087 : : qdisc_qstats_cpu_backlog_dec(sch, skb);
1088 : : qdisc_bstats_cpu_update(sch, skb);
1089 : 10145 : qdisc_qstats_cpu_qlen_dec(sch);
1090 : : } else {
1091 : : qdisc_qstats_backlog_dec(sch, skb);
1092 : : qdisc_bstats_update(sch, skb);
1093 : 0 : sch->q.qlen--;
1094 : : }
1095 : 10145 : }
1096 : :
1097 : 10145 : static inline void qdisc_update_stats_at_enqueue(struct Qdisc *sch,
1098 : : unsigned int pkt_len)
1099 : : {
1100 [ + - ]: 10145 : if (qdisc_is_percpu_stats(sch)) {
1101 : 10145 : qdisc_qstats_cpu_qlen_inc(sch);
1102 : 20290 : this_cpu_add(sch->cpu_qstats->backlog, pkt_len);
1103 : : } else {
1104 : 0 : sch->qstats.backlog += pkt_len;
1105 : 0 : sch->q.qlen++;
1106 : : }
1107 : 10145 : }
1108 : :
1109 : : /* use instead of qdisc->dequeue() for all qdiscs queried with ->peek() */
1110 : : static inline struct sk_buff *qdisc_dequeue_peeked(struct Qdisc *sch)
1111 : : {
1112 : : struct sk_buff *skb = skb_peek(&sch->gso_skb);
1113 : :
1114 : : if (skb) {
1115 : : skb = __skb_dequeue(&sch->gso_skb);
1116 : : if (qdisc_is_percpu_stats(sch)) {
1117 : : qdisc_qstats_cpu_backlog_dec(sch, skb);
1118 : : qdisc_qstats_cpu_qlen_dec(sch);
1119 : : } else {
1120 : : qdisc_qstats_backlog_dec(sch, skb);
1121 : : sch->q.qlen--;
1122 : : }
1123 : : } else {
1124 : : skb = sch->dequeue(sch);
1125 : : }
1126 : :
1127 : : return skb;
1128 : : }
1129 : :
1130 : 0 : static inline void __qdisc_reset_queue(struct qdisc_skb_head *qh)
1131 : : {
1132 : : /*
1133 : : * We do not know the backlog in bytes of this list, it
1134 : : * is up to the caller to correct it
1135 : : */
1136 [ # # # # ]: 0 : ASSERT_RTNL();
1137 [ # # ]: 0 : if (qh->qlen) {
1138 : 0 : rtnl_kfree_skbs(qh->head, qh->tail);
1139 : :
1140 : 0 : qh->head = NULL;
1141 : 0 : qh->tail = NULL;
1142 : 0 : qh->qlen = 0;
1143 : : }
1144 : 0 : }
1145 : :
1146 : 0 : static inline void qdisc_reset_queue(struct Qdisc *sch)
1147 : : {
1148 : 0 : __qdisc_reset_queue(&sch->q);
1149 : 0 : sch->qstats.backlog = 0;
1150 : 0 : }
1151 : :
1152 : : static inline struct Qdisc *qdisc_replace(struct Qdisc *sch, struct Qdisc *new,
1153 : : struct Qdisc **pold)
1154 : : {
1155 : : struct Qdisc *old;
1156 : :
1157 : : sch_tree_lock(sch);
1158 : : old = *pold;
1159 : : *pold = new;
1160 : : if (old != NULL)
1161 : : qdisc_tree_flush_backlog(old);
1162 : : sch_tree_unlock(sch);
1163 : :
1164 : : return old;
1165 : : }
1166 : :
1167 : : static inline void rtnl_qdisc_drop(struct sk_buff *skb, struct Qdisc *sch)
1168 : : {
1169 : : rtnl_kfree_skbs(skb, skb);
1170 : : qdisc_qstats_drop(sch);
1171 : : }
1172 : :
1173 : : static inline int qdisc_drop_cpu(struct sk_buff *skb, struct Qdisc *sch,
1174 : : struct sk_buff **to_free)
1175 : : {
1176 : : __qdisc_drop(skb, to_free);
1177 : 0 : qdisc_qstats_cpu_drop(sch);
1178 : :
1179 : : return NET_XMIT_DROP;
1180 : : }
1181 : :
1182 : : static inline int qdisc_drop(struct sk_buff *skb, struct Qdisc *sch,
1183 : : struct sk_buff **to_free)
1184 : : {
1185 : : __qdisc_drop(skb, to_free);
1186 : : qdisc_qstats_drop(sch);
1187 : :
1188 : : return NET_XMIT_DROP;
1189 : : }
1190 : :
1191 : : static inline int qdisc_drop_all(struct sk_buff *skb, struct Qdisc *sch,
1192 : : struct sk_buff **to_free)
1193 : : {
1194 : : __qdisc_drop_all(skb, to_free);
1195 : : qdisc_qstats_drop(sch);
1196 : :
1197 : : return NET_XMIT_DROP;
1198 : : }
1199 : :
1200 : : /* Length to Time (L2T) lookup in a qdisc_rate_table, to determine how
1201 : : long it will take to send a packet given its size.
1202 : : */
1203 : : static inline u32 qdisc_l2t(struct qdisc_rate_table* rtab, unsigned int pktlen)
1204 : : {
1205 : : int slot = pktlen + rtab->rate.cell_align + rtab->rate.overhead;
1206 : : if (slot < 0)
1207 : : slot = 0;
1208 : : slot >>= rtab->rate.cell_log;
1209 : : if (slot > 255)
1210 : : return rtab->data[255]*(slot >> 8) + rtab->data[slot & 0xFF];
1211 : : return rtab->data[slot];
1212 : : }
1213 : :
1214 : : struct psched_ratecfg {
1215 : : u64 rate_bytes_ps; /* bytes per second */
1216 : : u32 mult;
1217 : : u16 overhead;
1218 : : u8 linklayer;
1219 : : u8 shift;
1220 : : };
1221 : :
1222 : : static inline u64 psched_l2t_ns(const struct psched_ratecfg *r,
1223 : : unsigned int len)
1224 : : {
1225 : : len += r->overhead;
1226 : :
1227 : : if (unlikely(r->linklayer == TC_LINKLAYER_ATM))
1228 : : return ((u64)(DIV_ROUND_UP(len,48)*53) * r->mult) >> r->shift;
1229 : :
1230 : : return ((u64)len * r->mult) >> r->shift;
1231 : : }
1232 : :
1233 : : void psched_ratecfg_precompute(struct psched_ratecfg *r,
1234 : : const struct tc_ratespec *conf,
1235 : : u64 rate64);
1236 : :
1237 : : static inline void psched_ratecfg_getrate(struct tc_ratespec *res,
1238 : : const struct psched_ratecfg *r)
1239 : : {
1240 : : memset(res, 0, sizeof(*res));
1241 : :
1242 : : /* legacy struct tc_ratespec has a 32bit @rate field
1243 : : * Qdisc using 64bit rate should add new attributes
1244 : : * in order to maintain compatibility.
1245 : : */
1246 : : res->rate = min_t(u64, r->rate_bytes_ps, ~0U);
1247 : :
1248 : : res->overhead = r->overhead;
1249 : : res->linklayer = (r->linklayer & TC_LINKLAYER_MASK);
1250 : : }
1251 : :
1252 : : /* Mini Qdisc serves for specific needs of ingress/clsact Qdisc.
1253 : : * The fast path only needs to access filter list and to update stats
1254 : : */
1255 : : struct mini_Qdisc {
1256 : : struct tcf_proto *filter_list;
1257 : : struct gnet_stats_basic_cpu __percpu *cpu_bstats;
1258 : : struct gnet_stats_queue __percpu *cpu_qstats;
1259 : : struct rcu_head rcu;
1260 : : };
1261 : :
1262 : : static inline void mini_qdisc_bstats_cpu_update(struct mini_Qdisc *miniq,
1263 : : const struct sk_buff *skb)
1264 : : {
1265 : 0 : bstats_cpu_update(this_cpu_ptr(miniq->cpu_bstats), skb);
1266 : : }
1267 : :
1268 : 0 : static inline void mini_qdisc_qstats_cpu_drop(struct mini_Qdisc *miniq)
1269 : : {
1270 : 0 : this_cpu_inc(miniq->cpu_qstats->drops);
1271 : 0 : }
1272 : :
1273 : : struct mini_Qdisc_pair {
1274 : : struct mini_Qdisc miniq1;
1275 : : struct mini_Qdisc miniq2;
1276 : : struct mini_Qdisc __rcu **p_miniq;
1277 : : };
1278 : :
1279 : : void mini_qdisc_pair_swap(struct mini_Qdisc_pair *miniqp,
1280 : : struct tcf_proto *tp_head);
1281 : : void mini_qdisc_pair_init(struct mini_Qdisc_pair *miniqp, struct Qdisc *qdisc,
1282 : : struct mini_Qdisc __rcu **p_miniq);
1283 : :
1284 : : static inline void skb_tc_reinsert(struct sk_buff *skb, struct tcf_result *res)
1285 : : {
1286 : : struct gnet_stats_queue *stats = res->qstats;
1287 : : int ret;
1288 : :
1289 : : if (res->ingress)
1290 : : ret = netif_receive_skb(skb);
1291 : : else
1292 : : ret = dev_queue_xmit(skb);
1293 : : if (ret && stats)
1294 : : qstats_overlimit_inc(res->qstats);
1295 : : }
1296 : :
1297 : : #endif
|
