Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * net/sched/sch_generic.c Generic packet scheduler routines.
4 : : *
5 : : * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
6 : : * Jamal Hadi Salim, <hadi@cyberus.ca> 990601
7 : : * - Ingress support
8 : : */
9 : :
10 : : #include <linux/bitops.h>
11 : : #include <linux/module.h>
12 : : #include <linux/types.h>
13 : : #include <linux/kernel.h>
14 : : #include <linux/sched.h>
15 : : #include <linux/string.h>
16 : : #include <linux/errno.h>
17 : : #include <linux/netdevice.h>
18 : : #include <linux/skbuff.h>
19 : : #include <linux/rtnetlink.h>
20 : : #include <linux/init.h>
21 : : #include <linux/rcupdate.h>
22 : : #include <linux/list.h>
23 : : #include <linux/slab.h>
24 : : #include <linux/if_vlan.h>
25 : : #include <linux/skb_array.h>
26 : : #include <linux/if_macvlan.h>
27 : : #include <net/sch_generic.h>
28 : : #include <net/pkt_sched.h>
29 : : #include <net/dst.h>
30 : : #include <trace/events/qdisc.h>
31 : : #include <trace/events/net.h>
32 : : #include <net/xfrm.h>
33 : :
34 : : /* Qdisc to use by default */
35 : : const struct Qdisc_ops *default_qdisc_ops = &pfifo_fast_ops;
36 : : EXPORT_SYMBOL(default_qdisc_ops);
37 : :
38 : : /* Main transmission queue. */
39 : :
40 : : /* Modifications to data participating in scheduling must be protected with
41 : : * qdisc_lock(qdisc) spinlock.
42 : : *
43 : : * The idea is the following:
44 : : * - enqueue, dequeue are serialized via qdisc root lock
45 : : * - ingress filtering is also serialized via qdisc root lock
46 : : * - updates to tree and tree walking are only done under the rtnl mutex.
47 : : */
48 : :
49 : : #define SKB_XOFF_MAGIC ((struct sk_buff *)1UL)
50 : :
51 : 0 : static inline struct sk_buff *__skb_dequeue_bad_txq(struct Qdisc *q)
52 : : {
53 : 0 : const struct netdev_queue *txq = q->dev_queue;
54 : : spinlock_t *lock = NULL;
55 : : struct sk_buff *skb;
56 : :
57 : 0 : if (q->flags & TCQ_F_NOLOCK) {
58 : : lock = qdisc_lock(q);
59 : : spin_lock(lock);
60 : : }
61 : :
62 : 0 : skb = skb_peek(&q->skb_bad_txq);
63 : 0 : if (skb) {
64 : : /* check the reason of requeuing without tx lock first */
65 : 0 : txq = skb_get_tx_queue(txq->dev, skb);
66 : 0 : if (!netif_xmit_frozen_or_stopped(txq)) {
67 : : skb = __skb_dequeue(&q->skb_bad_txq);
68 : 0 : if (qdisc_is_percpu_stats(q)) {
69 : : qdisc_qstats_cpu_backlog_dec(q, skb);
70 : 0 : qdisc_qstats_cpu_qlen_dec(q);
71 : : } else {
72 : : qdisc_qstats_backlog_dec(q, skb);
73 : 0 : q->q.qlen--;
74 : : }
75 : : } else {
76 : : skb = SKB_XOFF_MAGIC;
77 : : }
78 : : }
79 : :
80 : 0 : if (lock)
81 : : spin_unlock(lock);
82 : :
83 : 0 : return skb;
84 : : }
85 : :
86 : : static inline struct sk_buff *qdisc_dequeue_skb_bad_txq(struct Qdisc *q)
87 : : {
88 : 3 : struct sk_buff *skb = skb_peek(&q->skb_bad_txq);
89 : :
90 : 3 : if (unlikely(skb))
91 : 0 : skb = __skb_dequeue_bad_txq(q);
92 : :
93 : : return skb;
94 : : }
95 : :
96 : 0 : static inline void qdisc_enqueue_skb_bad_txq(struct Qdisc *q,
97 : : struct sk_buff *skb)
98 : : {
99 : : spinlock_t *lock = NULL;
100 : :
101 : 0 : if (q->flags & TCQ_F_NOLOCK) {
102 : : lock = qdisc_lock(q);
103 : : spin_lock(lock);
104 : : }
105 : :
106 : 0 : __skb_queue_tail(&q->skb_bad_txq, skb);
107 : :
108 : 0 : if (qdisc_is_percpu_stats(q)) {
109 : : qdisc_qstats_cpu_backlog_inc(q, skb);
110 : 0 : qdisc_qstats_cpu_qlen_inc(q);
111 : : } else {
112 : : qdisc_qstats_backlog_inc(q, skb);
113 : 0 : q->q.qlen++;
114 : : }
115 : :
116 : 0 : if (lock)
117 : : spin_unlock(lock);
118 : 0 : }
119 : :
120 : 1 : static inline void dev_requeue_skb(struct sk_buff *skb, struct Qdisc *q)
121 : : {
122 : : spinlock_t *lock = NULL;
123 : :
124 : 1 : if (q->flags & TCQ_F_NOLOCK) {
125 : : lock = qdisc_lock(q);
126 : : spin_lock(lock);
127 : : }
128 : :
129 : 1 : while (skb) {
130 : 1 : struct sk_buff *next = skb->next;
131 : :
132 : 1 : __skb_queue_tail(&q->gso_skb, skb);
133 : :
134 : : /* it's still part of the queue */
135 : 1 : if (qdisc_is_percpu_stats(q)) {
136 : 1 : qdisc_qstats_cpu_requeues_inc(q);
137 : : qdisc_qstats_cpu_backlog_inc(q, skb);
138 : 1 : qdisc_qstats_cpu_qlen_inc(q);
139 : : } else {
140 : 0 : q->qstats.requeues++;
141 : : qdisc_qstats_backlog_inc(q, skb);
142 : 0 : q->q.qlen++;
143 : : }
144 : :
145 : : skb = next;
146 : : }
147 : 1 : if (lock)
148 : : spin_unlock(lock);
149 : 1 : __netif_schedule(q);
150 : 1 : }
151 : :
152 : 3 : static void try_bulk_dequeue_skb(struct Qdisc *q,
153 : : struct sk_buff *skb,
154 : : const struct netdev_queue *txq,
155 : : int *packets)
156 : : {
157 : 3 : int bytelimit = qdisc_avail_bulklimit(txq) - skb->len;
158 : :
159 : 3 : while (bytelimit > 0) {
160 : 0 : struct sk_buff *nskb = q->dequeue(q);
161 : :
162 : 0 : if (!nskb)
163 : : break;
164 : :
165 : 0 : bytelimit -= nskb->len; /* covers GSO len */
166 : 0 : skb->next = nskb;
167 : : skb = nskb;
168 : 0 : (*packets)++; /* GSO counts as one pkt */
169 : : }
170 : : skb_mark_not_on_list(skb);
171 : 3 : }
172 : :
173 : : /* This variant of try_bulk_dequeue_skb() makes sure
174 : : * all skbs in the chain are for the same txq
175 : : */
176 : 0 : static void try_bulk_dequeue_skb_slow(struct Qdisc *q,
177 : : struct sk_buff *skb,
178 : : int *packets)
179 : : {
180 : : int mapping = skb_get_queue_mapping(skb);
181 : : struct sk_buff *nskb;
182 : : int cnt = 0;
183 : :
184 : : do {
185 : 0 : nskb = q->dequeue(q);
186 : 0 : if (!nskb)
187 : : break;
188 : 0 : if (unlikely(skb_get_queue_mapping(nskb) != mapping)) {
189 : 0 : qdisc_enqueue_skb_bad_txq(q, nskb);
190 : 0 : break;
191 : : }
192 : 0 : skb->next = nskb;
193 : : skb = nskb;
194 : 0 : } while (++cnt < 8);
195 : 0 : (*packets) += cnt;
196 : : skb_mark_not_on_list(skb);
197 : 0 : }
198 : :
199 : : /* Note that dequeue_skb can possibly return a SKB list (via skb->next).
200 : : * A requeued skb (via q->gso_skb) can also be a SKB list.
201 : : */
202 : 3 : static struct sk_buff *dequeue_skb(struct Qdisc *q, bool *validate,
203 : : int *packets)
204 : : {
205 : 3 : const struct netdev_queue *txq = q->dev_queue;
206 : : struct sk_buff *skb = NULL;
207 : :
208 : 3 : *packets = 1;
209 : 3 : if (unlikely(!skb_queue_empty(&q->gso_skb))) {
210 : : spinlock_t *lock = NULL;
211 : :
212 : 1 : if (q->flags & TCQ_F_NOLOCK) {
213 : : lock = qdisc_lock(q);
214 : : spin_lock(lock);
215 : : }
216 : :
217 : : skb = skb_peek(&q->gso_skb);
218 : :
219 : : /* skb may be null if another cpu pulls gso_skb off in between
220 : : * empty check and lock.
221 : : */
222 : 1 : if (!skb) {
223 : 0 : if (lock)
224 : : spin_unlock(lock);
225 : : goto validate;
226 : : }
227 : :
228 : : /* skb in gso_skb were already validated */
229 : 1 : *validate = false;
230 : 1 : if (xfrm_offload(skb))
231 : 0 : *validate = true;
232 : : /* check the reason of requeuing without tx lock first */
233 : 1 : txq = skb_get_tx_queue(txq->dev, skb);
234 : 1 : if (!netif_xmit_frozen_or_stopped(txq)) {
235 : : skb = __skb_dequeue(&q->gso_skb);
236 : 1 : if (qdisc_is_percpu_stats(q)) {
237 : : qdisc_qstats_cpu_backlog_dec(q, skb);
238 : 1 : qdisc_qstats_cpu_qlen_dec(q);
239 : : } else {
240 : : qdisc_qstats_backlog_dec(q, skb);
241 : 0 : q->q.qlen--;
242 : : }
243 : : } else {
244 : : skb = NULL;
245 : : }
246 : 1 : if (lock)
247 : : spin_unlock(lock);
248 : : goto trace;
249 : : }
250 : : validate:
251 : 3 : *validate = true;
252 : :
253 : 3 : if ((q->flags & TCQ_F_ONETXQUEUE) &&
254 : : netif_xmit_frozen_or_stopped(txq))
255 : : return skb;
256 : :
257 : : skb = qdisc_dequeue_skb_bad_txq(q);
258 : 3 : if (unlikely(skb)) {
259 : 0 : if (skb == SKB_XOFF_MAGIC)
260 : : return NULL;
261 : : goto bulk;
262 : : }
263 : 3 : skb = q->dequeue(q);
264 : 3 : if (skb) {
265 : : bulk:
266 : 3 : if (qdisc_may_bulk(q))
267 : 3 : try_bulk_dequeue_skb(q, skb, txq, packets);
268 : : else
269 : 0 : try_bulk_dequeue_skb_slow(q, skb, packets);
270 : : }
271 : : trace:
272 : 3 : trace_qdisc_dequeue(q, txq, *packets, skb);
273 : 3 : return skb;
274 : : }
275 : :
276 : : /*
277 : : * Transmit possibly several skbs, and handle the return status as
278 : : * required. Owning running seqcount bit guarantees that
279 : : * only one CPU can execute this function.
280 : : *
281 : : * Returns to the caller:
282 : : * false - hardware queue frozen backoff
283 : : * true - feel free to send more pkts
284 : : */
285 : 3 : bool sch_direct_xmit(struct sk_buff *skb, struct Qdisc *q,
286 : : struct net_device *dev, struct netdev_queue *txq,
287 : : spinlock_t *root_lock, bool validate)
288 : : {
289 : 3 : int ret = NETDEV_TX_BUSY;
290 : 3 : bool again = false;
291 : :
292 : : /* And release qdisc */
293 : 3 : if (root_lock)
294 : : spin_unlock(root_lock);
295 : :
296 : : /* Note that we validate skb (GSO, checksum, ...) outside of locks */
297 : 3 : if (validate)
298 : 3 : skb = validate_xmit_skb_list(skb, dev, &again);
299 : :
300 : : #ifdef CONFIG_XFRM_OFFLOAD
301 : : if (unlikely(again)) {
302 : : if (root_lock)
303 : : spin_lock(root_lock);
304 : :
305 : : dev_requeue_skb(skb, q);
306 : : return false;
307 : : }
308 : : #endif
309 : :
310 : 3 : if (likely(skb)) {
311 : 3 : HARD_TX_LOCK(dev, txq, smp_processor_id());
312 : 3 : if (!netif_xmit_frozen_or_stopped(txq))
313 : 3 : skb = dev_hard_start_xmit(skb, dev, txq, &ret);
314 : :
315 : 3 : HARD_TX_UNLOCK(dev, txq);
316 : : } else {
317 : 0 : if (root_lock)
318 : : spin_lock(root_lock);
319 : : return true;
320 : : }
321 : :
322 : 3 : if (root_lock)
323 : : spin_lock(root_lock);
324 : :
325 : 3 : if (!dev_xmit_complete(ret)) {
326 : : /* Driver returned NETDEV_TX_BUSY - requeue skb */
327 : 1 : if (unlikely(ret != NETDEV_TX_BUSY))
328 : 0 : net_warn_ratelimited("BUG %s code %d qlen %d\n",
329 : : dev->name, ret, q->q.qlen);
330 : :
331 : 1 : dev_requeue_skb(skb, q);
332 : 1 : return false;
333 : : }
334 : :
335 : : return true;
336 : : }
337 : :
338 : : /*
339 : : * NOTE: Called under qdisc_lock(q) with locally disabled BH.
340 : : *
341 : : * running seqcount guarantees only one CPU can process
342 : : * this qdisc at a time. qdisc_lock(q) serializes queue accesses for
343 : : * this queue.
344 : : *
345 : : * netif_tx_lock serializes accesses to device driver.
346 : : *
347 : : * qdisc_lock(q) and netif_tx_lock are mutually exclusive,
348 : : * if one is grabbed, another must be free.
349 : : *
350 : : * Note, that this procedure can be called by a watchdog timer
351 : : *
352 : : * Returns to the caller:
353 : : * 0 - queue is empty or throttled.
354 : : * >0 - queue is not empty.
355 : : *
356 : : */
357 : 3 : static inline bool qdisc_restart(struct Qdisc *q, int *packets)
358 : : {
359 : : spinlock_t *root_lock = NULL;
360 : : struct netdev_queue *txq;
361 : : struct net_device *dev;
362 : : struct sk_buff *skb;
363 : : bool validate;
364 : :
365 : : /* Dequeue packet */
366 : 3 : skb = dequeue_skb(q, &validate, packets);
367 : 3 : if (unlikely(!skb))
368 : : return false;
369 : :
370 : 3 : if (!(q->flags & TCQ_F_NOLOCK))
371 : : root_lock = qdisc_lock(q);
372 : :
373 : : dev = qdisc_dev(q);
374 : : txq = skb_get_tx_queue(dev, skb);
375 : :
376 : 3 : return sch_direct_xmit(skb, q, dev, txq, root_lock, validate);
377 : : }
378 : :
379 : 3 : void __qdisc_run(struct Qdisc *q)
380 : : {
381 : 3 : int quota = dev_tx_weight;
382 : : int packets;
383 : :
384 : 3 : while (qdisc_restart(q, &packets)) {
385 : : /*
386 : : * Ordered by possible occurrence: Postpone processing if
387 : : * 1. we've exceeded packet quota
388 : : * 2. another process needs the CPU;
389 : : */
390 : 3 : quota -= packets;
391 : 3 : if (quota <= 0 || need_resched()) {
392 : 3 : __netif_schedule(q);
393 : 3 : break;
394 : : }
395 : : }
396 : 3 : }
397 : :
398 : 0 : unsigned long dev_trans_start(struct net_device *dev)
399 : : {
400 : : unsigned long val, res;
401 : : unsigned int i;
402 : :
403 : 0 : if (is_vlan_dev(dev))
404 : 0 : dev = vlan_dev_real_dev(dev);
405 : 0 : else if (netif_is_macvlan(dev))
406 : : dev = macvlan_dev_real_dev(dev);
407 : 0 : res = netdev_get_tx_queue(dev, 0)->trans_start;
408 : 0 : for (i = 1; i < dev->num_tx_queues; i++) {
409 : 0 : val = netdev_get_tx_queue(dev, i)->trans_start;
410 : 0 : if (val && time_after(val, res))
411 : : res = val;
412 : : }
413 : :
414 : 0 : return res;
415 : : }
416 : : EXPORT_SYMBOL(dev_trans_start);
417 : :
418 : 3 : static void dev_watchdog(struct timer_list *t)
419 : : {
420 : 3 : struct net_device *dev = from_timer(dev, t, watchdog_timer);
421 : :
422 : 3 : netif_tx_lock(dev);
423 : 3 : if (!qdisc_tx_is_noop(dev)) {
424 : 3 : if (netif_device_present(dev) &&
425 : 3 : netif_running(dev) &&
426 : : netif_carrier_ok(dev)) {
427 : : int some_queue_timedout = 0;
428 : : unsigned int i;
429 : : unsigned long trans_start;
430 : :
431 : 3 : for (i = 0; i < dev->num_tx_queues; i++) {
432 : : struct netdev_queue *txq;
433 : :
434 : : txq = netdev_get_tx_queue(dev, i);
435 : 3 : trans_start = txq->trans_start;
436 : 3 : if (netif_xmit_stopped(txq) &&
437 : 1 : time_after(jiffies, (trans_start +
438 : : dev->watchdog_timeo))) {
439 : : some_queue_timedout = 1;
440 : 0 : txq->trans_timeout++;
441 : 0 : break;
442 : : }
443 : : }
444 : :
445 : 3 : if (some_queue_timedout) {
446 : 0 : trace_net_dev_xmit_timeout(dev, i);
447 : 0 : WARN_ONCE(1, KERN_INFO "NETDEV WATCHDOG: %s (%s): transmit queue %u timed out\n",
448 : : dev->name, netdev_drivername(dev), i);
449 : 0 : dev->netdev_ops->ndo_tx_timeout(dev);
450 : : }
451 : 3 : if (!mod_timer(&dev->watchdog_timer,
452 : : round_jiffies(jiffies +
453 : 3 : dev->watchdog_timeo)))
454 : 3 : dev_hold(dev);
455 : : }
456 : : }
457 : 3 : netif_tx_unlock(dev);
458 : :
459 : 3 : dev_put(dev);
460 : 3 : }
461 : :
462 : 3 : void __netdev_watchdog_up(struct net_device *dev)
463 : : {
464 : 3 : if (dev->netdev_ops->ndo_tx_timeout) {
465 : 3 : if (dev->watchdog_timeo <= 0)
466 : 0 : dev->watchdog_timeo = 5*HZ;
467 : 3 : if (!mod_timer(&dev->watchdog_timer,
468 : 3 : round_jiffies(jiffies + dev->watchdog_timeo)))
469 : 3 : dev_hold(dev);
470 : : }
471 : 3 : }
472 : : EXPORT_SYMBOL_GPL(__netdev_watchdog_up);
473 : :
474 : : static void dev_watchdog_up(struct net_device *dev)
475 : : {
476 : 3 : __netdev_watchdog_up(dev);
477 : : }
478 : :
479 : 2 : static void dev_watchdog_down(struct net_device *dev)
480 : : {
481 : : netif_tx_lock_bh(dev);
482 : 2 : if (del_timer(&dev->watchdog_timer))
483 : 2 : dev_put(dev);
484 : : netif_tx_unlock_bh(dev);
485 : 2 : }
486 : :
487 : : /**
488 : : * netif_carrier_on - set carrier
489 : : * @dev: network device
490 : : *
491 : : * Device has detected acquisition of carrier.
492 : : */
493 : 2 : void netif_carrier_on(struct net_device *dev)
494 : : {
495 : 2 : if (test_and_clear_bit(__LINK_STATE_NOCARRIER, &dev->state)) {
496 : 2 : if (dev->reg_state == NETREG_UNINITIALIZED)
497 : 2 : return;
498 : 2 : atomic_inc(&dev->carrier_up_count);
499 : 2 : linkwatch_fire_event(dev);
500 : 2 : if (netif_running(dev))
501 : 2 : __netdev_watchdog_up(dev);
502 : : }
503 : : }
504 : : EXPORT_SYMBOL(netif_carrier_on);
505 : :
506 : : /**
507 : : * netif_carrier_off - clear carrier
508 : : * @dev: network device
509 : : *
510 : : * Device has detected loss of carrier.
511 : : */
512 : 2 : void netif_carrier_off(struct net_device *dev)
513 : : {
514 : 2 : if (!test_and_set_bit(__LINK_STATE_NOCARRIER, &dev->state)) {
515 : 2 : if (dev->reg_state == NETREG_UNINITIALIZED)
516 : 2 : return;
517 : 2 : atomic_inc(&dev->carrier_down_count);
518 : 2 : linkwatch_fire_event(dev);
519 : : }
520 : : }
521 : : EXPORT_SYMBOL(netif_carrier_off);
522 : :
523 : : /* "NOOP" scheduler: the best scheduler, recommended for all interfaces
524 : : under all circumstances. It is difficult to invent anything faster or
525 : : cheaper.
526 : : */
527 : :
528 : 2 : static int noop_enqueue(struct sk_buff *skb, struct Qdisc *qdisc,
529 : : struct sk_buff **to_free)
530 : : {
531 : : __qdisc_drop(skb, to_free);
532 : 2 : return NET_XMIT_CN;
533 : : }
534 : :
535 : 2 : static struct sk_buff *noop_dequeue(struct Qdisc *qdisc)
536 : : {
537 : 2 : return NULL;
538 : : }
539 : :
540 : : struct Qdisc_ops noop_qdisc_ops __read_mostly = {
541 : : .id = "noop",
542 : : .priv_size = 0,
543 : : .enqueue = noop_enqueue,
544 : : .dequeue = noop_dequeue,
545 : : .peek = noop_dequeue,
546 : : .owner = THIS_MODULE,
547 : : };
548 : :
549 : : static struct netdev_queue noop_netdev_queue = {
550 : : RCU_POINTER_INITIALIZER(qdisc, &noop_qdisc),
551 : : .qdisc_sleeping = &noop_qdisc,
552 : : };
553 : :
554 : : struct Qdisc noop_qdisc = {
555 : : .enqueue = noop_enqueue,
556 : : .dequeue = noop_dequeue,
557 : : .flags = TCQ_F_BUILTIN,
558 : : .ops = &noop_qdisc_ops,
559 : : .q.lock = __SPIN_LOCK_UNLOCKED(noop_qdisc.q.lock),
560 : : .dev_queue = &noop_netdev_queue,
561 : : .running = SEQCNT_ZERO(noop_qdisc.running),
562 : : .busylock = __SPIN_LOCK_UNLOCKED(noop_qdisc.busylock),
563 : : .gso_skb = {
564 : : .next = (struct sk_buff *)&noop_qdisc.gso_skb,
565 : : .prev = (struct sk_buff *)&noop_qdisc.gso_skb,
566 : : .qlen = 0,
567 : : .lock = __SPIN_LOCK_UNLOCKED(noop_qdisc.gso_skb.lock),
568 : : },
569 : : .skb_bad_txq = {
570 : : .next = (struct sk_buff *)&noop_qdisc.skb_bad_txq,
571 : : .prev = (struct sk_buff *)&noop_qdisc.skb_bad_txq,
572 : : .qlen = 0,
573 : : .lock = __SPIN_LOCK_UNLOCKED(noop_qdisc.skb_bad_txq.lock),
574 : : },
575 : : };
576 : : EXPORT_SYMBOL(noop_qdisc);
577 : :
578 : 3 : static int noqueue_init(struct Qdisc *qdisc, struct nlattr *opt,
579 : : struct netlink_ext_ack *extack)
580 : : {
581 : : /* register_qdisc() assigns a default of noop_enqueue if unset,
582 : : * but __dev_queue_xmit() treats noqueue only as such
583 : : * if this is NULL - so clear it here. */
584 : 3 : qdisc->enqueue = NULL;
585 : 3 : return 0;
586 : : }
587 : :
588 : : struct Qdisc_ops noqueue_qdisc_ops __read_mostly = {
589 : : .id = "noqueue",
590 : : .priv_size = 0,
591 : : .init = noqueue_init,
592 : : .enqueue = noop_enqueue,
593 : : .dequeue = noop_dequeue,
594 : : .peek = noop_dequeue,
595 : : .owner = THIS_MODULE,
596 : : };
597 : :
598 : : static const u8 prio2band[TC_PRIO_MAX + 1] = {
599 : : 1, 2, 2, 2, 1, 2, 0, 0 , 1, 1, 1, 1, 1, 1, 1, 1
600 : : };
601 : :
602 : : /* 3-band FIFO queue: old style, but should be a bit faster than
603 : : generic prio+fifo combination.
604 : : */
605 : :
606 : : #define PFIFO_FAST_BANDS 3
607 : :
608 : : /*
609 : : * Private data for a pfifo_fast scheduler containing:
610 : : * - rings for priority bands
611 : : */
612 : : struct pfifo_fast_priv {
613 : : struct skb_array q[PFIFO_FAST_BANDS];
614 : : };
615 : :
616 : : static inline struct skb_array *band2list(struct pfifo_fast_priv *priv,
617 : : int band)
618 : : {
619 : 3 : return &priv->q[band];
620 : : }
621 : :
622 : 3 : static int pfifo_fast_enqueue(struct sk_buff *skb, struct Qdisc *qdisc,
623 : : struct sk_buff **to_free)
624 : : {
625 : 3 : int band = prio2band[skb->priority & TC_PRIO_MAX];
626 : : struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
627 : : struct skb_array *q = band2list(priv, band);
628 : : unsigned int pkt_len = qdisc_pkt_len(skb);
629 : : int err;
630 : :
631 : : err = skb_array_produce(q, skb);
632 : :
633 : 3 : if (unlikely(err)) {
634 : 0 : if (qdisc_is_percpu_stats(qdisc))
635 : 0 : return qdisc_drop_cpu(skb, qdisc, to_free);
636 : : else
637 : 0 : return qdisc_drop(skb, qdisc, to_free);
638 : : }
639 : :
640 : 3 : qdisc_update_stats_at_enqueue(qdisc, pkt_len);
641 : 3 : return NET_XMIT_SUCCESS;
642 : : }
643 : :
644 : 3 : static struct sk_buff *pfifo_fast_dequeue(struct Qdisc *qdisc)
645 : : {
646 : : struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
647 : : struct sk_buff *skb = NULL;
648 : : int band;
649 : :
650 : 3 : for (band = 0; band < PFIFO_FAST_BANDS && !skb; band++) {
651 : : struct skb_array *q = band2list(priv, band);
652 : :
653 : 3 : if (__skb_array_empty(q))
654 : 3 : continue;
655 : :
656 : : skb = __skb_array_consume(q);
657 : : }
658 : 3 : if (likely(skb)) {
659 : 3 : qdisc_update_stats_at_dequeue(qdisc, skb);
660 : : } else {
661 : : WRITE_ONCE(qdisc->empty, true);
662 : : }
663 : :
664 : 3 : return skb;
665 : : }
666 : :
667 : 0 : static struct sk_buff *pfifo_fast_peek(struct Qdisc *qdisc)
668 : : {
669 : : struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
670 : : struct sk_buff *skb = NULL;
671 : : int band;
672 : :
673 : 0 : for (band = 0; band < PFIFO_FAST_BANDS && !skb; band++) {
674 : : struct skb_array *q = band2list(priv, band);
675 : :
676 : : skb = __skb_array_peek(q);
677 : : }
678 : :
679 : 0 : return skb;
680 : : }
681 : :
682 : 2 : static void pfifo_fast_reset(struct Qdisc *qdisc)
683 : : {
684 : : int i, band;
685 : : struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
686 : :
687 : 2 : for (band = 0; band < PFIFO_FAST_BANDS; band++) {
688 : : struct skb_array *q = band2list(priv, band);
689 : : struct sk_buff *skb;
690 : :
691 : : /* NULL ring is possible if destroy path is due to a failed
692 : : * skb_array_init() in pfifo_fast_init() case.
693 : : */
694 : 2 : if (!q->ring.queue)
695 : 0 : continue;
696 : :
697 : 2 : while ((skb = __skb_array_consume(q)) != NULL)
698 : 0 : kfree_skb(skb);
699 : : }
700 : :
701 : 2 : if (qdisc_is_percpu_stats(qdisc)) {
702 : 2 : for_each_possible_cpu(i) {
703 : : struct gnet_stats_queue *q;
704 : :
705 : 2 : q = per_cpu_ptr(qdisc->cpu_qstats, i);
706 : 2 : q->backlog = 0;
707 : 2 : q->qlen = 0;
708 : : }
709 : : }
710 : 2 : }
711 : :
712 : 0 : static int pfifo_fast_dump(struct Qdisc *qdisc, struct sk_buff *skb)
713 : : {
714 : 0 : struct tc_prio_qopt opt = { .bands = PFIFO_FAST_BANDS };
715 : :
716 : 0 : memcpy(&opt.priomap, prio2band, TC_PRIO_MAX + 1);
717 : 0 : if (nla_put(skb, TCA_OPTIONS, sizeof(opt), &opt))
718 : : goto nla_put_failure;
719 : 0 : return skb->len;
720 : :
721 : : nla_put_failure:
722 : : return -1;
723 : : }
724 : :
725 : 3 : static int pfifo_fast_init(struct Qdisc *qdisc, struct nlattr *opt,
726 : : struct netlink_ext_ack *extack)
727 : : {
728 : 3 : unsigned int qlen = qdisc_dev(qdisc)->tx_queue_len;
729 : : struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
730 : : int prio;
731 : :
732 : : /* guard against zero length rings */
733 : 3 : if (!qlen)
734 : : return -EINVAL;
735 : :
736 : 3 : for (prio = 0; prio < PFIFO_FAST_BANDS; prio++) {
737 : : struct skb_array *q = band2list(priv, prio);
738 : : int err;
739 : :
740 : 3 : err = skb_array_init(q, qlen, GFP_KERNEL);
741 : 3 : if (err)
742 : : return -ENOMEM;
743 : : }
744 : :
745 : : /* Can by-pass the queue discipline */
746 : 3 : qdisc->flags |= TCQ_F_CAN_BYPASS;
747 : 3 : return 0;
748 : : }
749 : :
750 : 0 : static void pfifo_fast_destroy(struct Qdisc *sch)
751 : : {
752 : : struct pfifo_fast_priv *priv = qdisc_priv(sch);
753 : : int prio;
754 : :
755 : 0 : for (prio = 0; prio < PFIFO_FAST_BANDS; prio++) {
756 : : struct skb_array *q = band2list(priv, prio);
757 : :
758 : : /* NULL ring is possible if destroy path is due to a failed
759 : : * skb_array_init() in pfifo_fast_init() case.
760 : : */
761 : 0 : if (!q->ring.queue)
762 : 0 : continue;
763 : : /* Destroy ring but no need to kfree_skb because a call to
764 : : * pfifo_fast_reset() has already done that work.
765 : : */
766 : 0 : ptr_ring_cleanup(&q->ring, NULL);
767 : : }
768 : 0 : }
769 : :
770 : 0 : static int pfifo_fast_change_tx_queue_len(struct Qdisc *sch,
771 : : unsigned int new_len)
772 : : {
773 : : struct pfifo_fast_priv *priv = qdisc_priv(sch);
774 : : struct skb_array *bands[PFIFO_FAST_BANDS];
775 : : int prio;
776 : :
777 : 0 : for (prio = 0; prio < PFIFO_FAST_BANDS; prio++) {
778 : : struct skb_array *q = band2list(priv, prio);
779 : :
780 : 0 : bands[prio] = q;
781 : : }
782 : :
783 : 0 : return skb_array_resize_multiple(bands, PFIFO_FAST_BANDS, new_len,
784 : : GFP_KERNEL);
785 : : }
786 : :
787 : : struct Qdisc_ops pfifo_fast_ops __read_mostly = {
788 : : .id = "pfifo_fast",
789 : : .priv_size = sizeof(struct pfifo_fast_priv),
790 : : .enqueue = pfifo_fast_enqueue,
791 : : .dequeue = pfifo_fast_dequeue,
792 : : .peek = pfifo_fast_peek,
793 : : .init = pfifo_fast_init,
794 : : .destroy = pfifo_fast_destroy,
795 : : .reset = pfifo_fast_reset,
796 : : .dump = pfifo_fast_dump,
797 : : .change_tx_queue_len = pfifo_fast_change_tx_queue_len,
798 : : .owner = THIS_MODULE,
799 : : .static_flags = TCQ_F_NOLOCK | TCQ_F_CPUSTATS,
800 : : };
801 : : EXPORT_SYMBOL(pfifo_fast_ops);
802 : :
803 : 3 : struct Qdisc *qdisc_alloc(struct netdev_queue *dev_queue,
804 : : const struct Qdisc_ops *ops,
805 : : struct netlink_ext_ack *extack)
806 : : {
807 : : void *p;
808 : : struct Qdisc *sch;
809 : 3 : unsigned int size = QDISC_ALIGN(sizeof(*sch)) + ops->priv_size;
810 : : int err = -ENOBUFS;
811 : : struct net_device *dev;
812 : :
813 : 3 : if (!dev_queue) {
814 : 0 : NL_SET_ERR_MSG(extack, "No device queue given");
815 : : err = -EINVAL;
816 : : goto errout;
817 : : }
818 : :
819 : 3 : dev = dev_queue->dev;
820 : 3 : p = kzalloc_node(size, GFP_KERNEL,
821 : : netdev_queue_numa_node_read(dev_queue));
822 : :
823 : 3 : if (!p)
824 : : goto errout;
825 : 3 : sch = (struct Qdisc *) QDISC_ALIGN((unsigned long) p);
826 : : /* if we got non aligned memory, ask more and do alignment ourself */
827 : 3 : if (sch != p) {
828 : 0 : kfree(p);
829 : 0 : p = kzalloc_node(size + QDISC_ALIGNTO - 1, GFP_KERNEL,
830 : : netdev_queue_numa_node_read(dev_queue));
831 : 0 : if (!p)
832 : : goto errout;
833 : 0 : sch = (struct Qdisc *) QDISC_ALIGN((unsigned long) p);
834 : 0 : sch->padded = (char *) sch - (char *) p;
835 : : }
836 : 3 : __skb_queue_head_init(&sch->gso_skb);
837 : 3 : __skb_queue_head_init(&sch->skb_bad_txq);
838 : : qdisc_skb_head_init(&sch->q);
839 : 3 : spin_lock_init(&sch->q.lock);
840 : :
841 : 3 : if (ops->static_flags & TCQ_F_CPUSTATS) {
842 : 3 : sch->cpu_bstats =
843 : 3 : netdev_alloc_pcpu_stats(struct gnet_stats_basic_cpu);
844 : 3 : if (!sch->cpu_bstats)
845 : : goto errout1;
846 : :
847 : 3 : sch->cpu_qstats = alloc_percpu(struct gnet_stats_queue);
848 : 3 : if (!sch->cpu_qstats) {
849 : 0 : free_percpu(sch->cpu_bstats);
850 : 0 : goto errout1;
851 : : }
852 : : }
853 : :
854 : 3 : spin_lock_init(&sch->busylock);
855 : : /* seqlock has the same scope of busylock, for NOLOCK qdisc */
856 : 3 : spin_lock_init(&sch->seqlock);
857 : : seqcount_init(&sch->running);
858 : :
859 : 3 : sch->ops = ops;
860 : 3 : sch->flags = ops->static_flags;
861 : 3 : sch->enqueue = ops->enqueue;
862 : 3 : sch->dequeue = ops->dequeue;
863 : 3 : sch->dev_queue = dev_queue;
864 : 3 : sch->empty = true;
865 : 3 : dev_hold(dev);
866 : : refcount_set(&sch->refcnt, 1);
867 : :
868 : : if (sch != &noop_qdisc) {
869 : : lockdep_set_class(&sch->busylock, &dev->qdisc_tx_busylock_key);
870 : : lockdep_set_class(&sch->seqlock, &dev->qdisc_tx_busylock_key);
871 : : lockdep_set_class(&sch->running, &dev->qdisc_running_key);
872 : : }
873 : :
874 : 3 : return sch;
875 : : errout1:
876 : 0 : kfree(p);
877 : : errout:
878 : 0 : return ERR_PTR(err);
879 : : }
880 : :
881 : 3 : struct Qdisc *qdisc_create_dflt(struct netdev_queue *dev_queue,
882 : : const struct Qdisc_ops *ops,
883 : : unsigned int parentid,
884 : : struct netlink_ext_ack *extack)
885 : : {
886 : : struct Qdisc *sch;
887 : :
888 : 3 : if (!try_module_get(ops->owner)) {
889 : 0 : NL_SET_ERR_MSG(extack, "Failed to increase module reference counter");
890 : : return NULL;
891 : : }
892 : :
893 : 3 : sch = qdisc_alloc(dev_queue, ops, extack);
894 : 3 : if (IS_ERR(sch)) {
895 : 0 : module_put(ops->owner);
896 : 0 : return NULL;
897 : : }
898 : 3 : sch->parent = parentid;
899 : :
900 : 3 : if (!ops->init || ops->init(sch, NULL, extack) == 0)
901 : 3 : return sch;
902 : :
903 : 0 : qdisc_put(sch);
904 : 0 : return NULL;
905 : : }
906 : : EXPORT_SYMBOL(qdisc_create_dflt);
907 : :
908 : : /* Under qdisc_lock(qdisc) and BH! */
909 : :
910 : 2 : void qdisc_reset(struct Qdisc *qdisc)
911 : : {
912 : 2 : const struct Qdisc_ops *ops = qdisc->ops;
913 : : struct sk_buff *skb, *tmp;
914 : :
915 : 2 : if (ops->reset)
916 : 2 : ops->reset(qdisc);
917 : :
918 : 2 : skb_queue_walk_safe(&qdisc->gso_skb, skb, tmp) {
919 : : __skb_unlink(skb, &qdisc->gso_skb);
920 : 0 : kfree_skb_list(skb);
921 : : }
922 : :
923 : 2 : skb_queue_walk_safe(&qdisc->skb_bad_txq, skb, tmp) {
924 : : __skb_unlink(skb, &qdisc->skb_bad_txq);
925 : 0 : kfree_skb_list(skb);
926 : : }
927 : :
928 : 2 : qdisc->q.qlen = 0;
929 : 2 : qdisc->qstats.backlog = 0;
930 : 2 : }
931 : : EXPORT_SYMBOL(qdisc_reset);
932 : :
933 : 0 : void qdisc_free(struct Qdisc *qdisc)
934 : : {
935 : 0 : if (qdisc_is_percpu_stats(qdisc)) {
936 : 0 : free_percpu(qdisc->cpu_bstats);
937 : 0 : free_percpu(qdisc->cpu_qstats);
938 : : }
939 : :
940 : 0 : kfree((char *) qdisc - qdisc->padded);
941 : 0 : }
942 : :
943 : 0 : static void qdisc_free_cb(struct rcu_head *head)
944 : : {
945 : 0 : struct Qdisc *q = container_of(head, struct Qdisc, rcu);
946 : :
947 : 0 : qdisc_free(q);
948 : 0 : }
949 : :
950 : 0 : static void qdisc_destroy(struct Qdisc *qdisc)
951 : : {
952 : 0 : const struct Qdisc_ops *ops = qdisc->ops;
953 : : struct sk_buff *skb, *tmp;
954 : :
955 : : #ifdef CONFIG_NET_SCHED
956 : 0 : qdisc_hash_del(qdisc);
957 : :
958 : 0 : qdisc_put_stab(rtnl_dereference(qdisc->stab));
959 : : #endif
960 : 0 : gen_kill_estimator(&qdisc->rate_est);
961 : 0 : if (ops->reset)
962 : 0 : ops->reset(qdisc);
963 : 0 : if (ops->destroy)
964 : 0 : ops->destroy(qdisc);
965 : :
966 : 0 : module_put(ops->owner);
967 : 0 : dev_put(qdisc_dev(qdisc));
968 : :
969 : 0 : skb_queue_walk_safe(&qdisc->gso_skb, skb, tmp) {
970 : : __skb_unlink(skb, &qdisc->gso_skb);
971 : 0 : kfree_skb_list(skb);
972 : : }
973 : :
974 : 0 : skb_queue_walk_safe(&qdisc->skb_bad_txq, skb, tmp) {
975 : : __skb_unlink(skb, &qdisc->skb_bad_txq);
976 : 0 : kfree_skb_list(skb);
977 : : }
978 : :
979 : 0 : call_rcu(&qdisc->rcu, qdisc_free_cb);
980 : 0 : }
981 : :
982 : 1 : void qdisc_put(struct Qdisc *qdisc)
983 : : {
984 : 1 : if (!qdisc)
985 : : return;
986 : :
987 : 1 : if (qdisc->flags & TCQ_F_BUILTIN ||
988 : 0 : !refcount_dec_and_test(&qdisc->refcnt))
989 : : return;
990 : :
991 : 0 : qdisc_destroy(qdisc);
992 : : }
993 : : EXPORT_SYMBOL(qdisc_put);
994 : :
995 : : /* Version of qdisc_put() that is called with rtnl mutex unlocked.
996 : : * Intended to be used as optimization, this function only takes rtnl lock if
997 : : * qdisc reference counter reached zero.
998 : : */
999 : :
1000 : 0 : void qdisc_put_unlocked(struct Qdisc *qdisc)
1001 : : {
1002 : 0 : if (qdisc->flags & TCQ_F_BUILTIN ||
1003 : 0 : !refcount_dec_and_rtnl_lock(&qdisc->refcnt))
1004 : 0 : return;
1005 : :
1006 : 0 : qdisc_destroy(qdisc);
1007 : 0 : rtnl_unlock();
1008 : : }
1009 : : EXPORT_SYMBOL(qdisc_put_unlocked);
1010 : :
1011 : : /* Attach toplevel qdisc to device queue. */
1012 : 0 : struct Qdisc *dev_graft_qdisc(struct netdev_queue *dev_queue,
1013 : : struct Qdisc *qdisc)
1014 : : {
1015 : 0 : struct Qdisc *oqdisc = dev_queue->qdisc_sleeping;
1016 : : spinlock_t *root_lock;
1017 : :
1018 : : root_lock = qdisc_lock(oqdisc);
1019 : : spin_lock_bh(root_lock);
1020 : :
1021 : : /* ... and graft new one */
1022 : 0 : if (qdisc == NULL)
1023 : : qdisc = &noop_qdisc;
1024 : 0 : dev_queue->qdisc_sleeping = qdisc;
1025 : 0 : rcu_assign_pointer(dev_queue->qdisc, &noop_qdisc);
1026 : :
1027 : : spin_unlock_bh(root_lock);
1028 : :
1029 : 0 : return oqdisc;
1030 : : }
1031 : : EXPORT_SYMBOL(dev_graft_qdisc);
1032 : :
1033 : 3 : static void attach_one_default_qdisc(struct net_device *dev,
1034 : : struct netdev_queue *dev_queue,
1035 : : void *_unused)
1036 : : {
1037 : : struct Qdisc *qdisc;
1038 : 3 : const struct Qdisc_ops *ops = default_qdisc_ops;
1039 : :
1040 : 3 : if (dev->priv_flags & IFF_NO_QUEUE)
1041 : : ops = &noqueue_qdisc_ops;
1042 : 3 : else if(dev->type == ARPHRD_CAN)
1043 : : ops = &pfifo_fast_ops;
1044 : :
1045 : 3 : qdisc = qdisc_create_dflt(dev_queue, ops, TC_H_ROOT, NULL);
1046 : 3 : if (!qdisc) {
1047 : 0 : netdev_info(dev, "activation failed\n");
1048 : 3 : return;
1049 : : }
1050 : 3 : if (!netif_is_multiqueue(dev))
1051 : 3 : qdisc->flags |= TCQ_F_ONETXQUEUE | TCQ_F_NOPARENT;
1052 : 3 : dev_queue->qdisc_sleeping = qdisc;
1053 : : }
1054 : :
1055 : 3 : static void attach_default_qdiscs(struct net_device *dev)
1056 : : {
1057 : : struct netdev_queue *txq;
1058 : : struct Qdisc *qdisc;
1059 : :
1060 : : txq = netdev_get_tx_queue(dev, 0);
1061 : :
1062 : 3 : if (!netif_is_multiqueue(dev) ||
1063 : 0 : dev->priv_flags & IFF_NO_QUEUE) {
1064 : : netdev_for_each_tx_queue(dev, attach_one_default_qdisc, NULL);
1065 : 3 : dev->qdisc = txq->qdisc_sleeping;
1066 : : qdisc_refcount_inc(dev->qdisc);
1067 : : } else {
1068 : 0 : qdisc = qdisc_create_dflt(txq, &mq_qdisc_ops, TC_H_ROOT, NULL);
1069 : 0 : if (qdisc) {
1070 : 0 : dev->qdisc = qdisc;
1071 : 0 : qdisc->ops->attach(qdisc);
1072 : : }
1073 : : }
1074 : : #ifdef CONFIG_NET_SCHED
1075 : 3 : if (dev->qdisc != &noop_qdisc)
1076 : 3 : qdisc_hash_add(dev->qdisc, false);
1077 : : #endif
1078 : 3 : }
1079 : :
1080 : 3 : static void transition_one_qdisc(struct net_device *dev,
1081 : : struct netdev_queue *dev_queue,
1082 : : void *_need_watchdog)
1083 : : {
1084 : 3 : struct Qdisc *new_qdisc = dev_queue->qdisc_sleeping;
1085 : : int *need_watchdog_p = _need_watchdog;
1086 : :
1087 : 3 : if (!(new_qdisc->flags & TCQ_F_BUILTIN))
1088 : 3 : clear_bit(__QDISC_STATE_DEACTIVATED, &new_qdisc->state);
1089 : :
1090 : 3 : rcu_assign_pointer(dev_queue->qdisc, new_qdisc);
1091 : 3 : if (need_watchdog_p) {
1092 : 3 : dev_queue->trans_start = 0;
1093 : 3 : *need_watchdog_p = 1;
1094 : : }
1095 : 3 : }
1096 : :
1097 : 3 : void dev_activate(struct net_device *dev)
1098 : : {
1099 : : int need_watchdog;
1100 : :
1101 : : /* No queueing discipline is attached to device;
1102 : : * create default one for devices, which need queueing
1103 : : * and noqueue_qdisc for virtual interfaces
1104 : : */
1105 : :
1106 : 3 : if (dev->qdisc == &noop_qdisc)
1107 : 3 : attach_default_qdiscs(dev);
1108 : :
1109 : 3 : if (!netif_carrier_ok(dev))
1110 : : /* Delay activation until next carrier-on event */
1111 : 0 : return;
1112 : :
1113 : 3 : need_watchdog = 0;
1114 : : netdev_for_each_tx_queue(dev, transition_one_qdisc, &need_watchdog);
1115 : 3 : if (dev_ingress_queue(dev))
1116 : 0 : transition_one_qdisc(dev, dev_ingress_queue(dev), NULL);
1117 : :
1118 : 3 : if (need_watchdog) {
1119 : : netif_trans_update(dev);
1120 : : dev_watchdog_up(dev);
1121 : : }
1122 : : }
1123 : : EXPORT_SYMBOL(dev_activate);
1124 : :
1125 : 2 : static void dev_deactivate_queue(struct net_device *dev,
1126 : : struct netdev_queue *dev_queue,
1127 : : void *_qdisc_default)
1128 : : {
1129 : : struct Qdisc *qdisc_default = _qdisc_default;
1130 : : struct Qdisc *qdisc;
1131 : :
1132 : 2 : qdisc = rtnl_dereference(dev_queue->qdisc);
1133 : 2 : if (qdisc) {
1134 : 2 : bool nolock = qdisc->flags & TCQ_F_NOLOCK;
1135 : :
1136 : 2 : if (nolock)
1137 : : spin_lock_bh(&qdisc->seqlock);
1138 : : spin_lock_bh(qdisc_lock(qdisc));
1139 : :
1140 : 2 : if (!(qdisc->flags & TCQ_F_BUILTIN))
1141 : 2 : set_bit(__QDISC_STATE_DEACTIVATED, &qdisc->state);
1142 : :
1143 : 2 : rcu_assign_pointer(dev_queue->qdisc, qdisc_default);
1144 : 2 : qdisc_reset(qdisc);
1145 : :
1146 : : spin_unlock_bh(qdisc_lock(qdisc));
1147 : 2 : if (nolock)
1148 : : spin_unlock_bh(&qdisc->seqlock);
1149 : : }
1150 : 2 : }
1151 : :
1152 : 2 : static bool some_qdisc_is_busy(struct net_device *dev)
1153 : : {
1154 : : unsigned int i;
1155 : :
1156 : 2 : for (i = 0; i < dev->num_tx_queues; i++) {
1157 : : struct netdev_queue *dev_queue;
1158 : : spinlock_t *root_lock;
1159 : : struct Qdisc *q;
1160 : : int val;
1161 : :
1162 : : dev_queue = netdev_get_tx_queue(dev, i);
1163 : 2 : q = dev_queue->qdisc_sleeping;
1164 : :
1165 : : root_lock = qdisc_lock(q);
1166 : : spin_lock_bh(root_lock);
1167 : :
1168 : 2 : val = (qdisc_is_running(q) ||
1169 : : test_bit(__QDISC_STATE_SCHED, &q->state));
1170 : :
1171 : : spin_unlock_bh(root_lock);
1172 : :
1173 : 2 : if (val)
1174 : : return true;
1175 : : }
1176 : : return false;
1177 : : }
1178 : :
1179 : 2 : static void dev_qdisc_reset(struct net_device *dev,
1180 : : struct netdev_queue *dev_queue,
1181 : : void *none)
1182 : : {
1183 : 2 : struct Qdisc *qdisc = dev_queue->qdisc_sleeping;
1184 : :
1185 : 2 : if (qdisc)
1186 : 2 : qdisc_reset(qdisc);
1187 : 2 : }
1188 : :
1189 : : /**
1190 : : * dev_deactivate_many - deactivate transmissions on several devices
1191 : : * @head: list of devices to deactivate
1192 : : *
1193 : : * This function returns only when all outstanding transmissions
1194 : : * have completed, unless all devices are in dismantle phase.
1195 : : */
1196 : 3 : void dev_deactivate_many(struct list_head *head)
1197 : : {
1198 : : struct net_device *dev;
1199 : :
1200 : 3 : list_for_each_entry(dev, head, close_list) {
1201 : : netdev_for_each_tx_queue(dev, dev_deactivate_queue,
1202 : : &noop_qdisc);
1203 : 2 : if (dev_ingress_queue(dev))
1204 : 0 : dev_deactivate_queue(dev, dev_ingress_queue(dev),
1205 : : &noop_qdisc);
1206 : :
1207 : 2 : dev_watchdog_down(dev);
1208 : : }
1209 : :
1210 : : /* Wait for outstanding qdisc-less dev_queue_xmit calls.
1211 : : * This is avoided if all devices are in dismantle phase :
1212 : : * Caller will call synchronize_net() for us
1213 : : */
1214 : 3 : synchronize_net();
1215 : :
1216 : : /* Wait for outstanding qdisc_run calls. */
1217 : 3 : list_for_each_entry(dev, head, close_list) {
1218 : 2 : while (some_qdisc_is_busy(dev))
1219 : 0 : yield();
1220 : : /* The new qdisc is assigned at this point so we can safely
1221 : : * unwind stale skb lists and qdisc statistics
1222 : : */
1223 : : netdev_for_each_tx_queue(dev, dev_qdisc_reset, NULL);
1224 : 2 : if (dev_ingress_queue(dev))
1225 : : dev_qdisc_reset(dev, dev_ingress_queue(dev), NULL);
1226 : : }
1227 : 3 : }
1228 : :
1229 : 2 : void dev_deactivate(struct net_device *dev)
1230 : : {
1231 : 2 : LIST_HEAD(single);
1232 : :
1233 : 2 : list_add(&dev->close_list, &single);
1234 : 2 : dev_deactivate_many(&single);
1235 : : list_del(&single);
1236 : 2 : }
1237 : : EXPORT_SYMBOL(dev_deactivate);
1238 : :
1239 : : static int qdisc_change_tx_queue_len(struct net_device *dev,
1240 : : struct netdev_queue *dev_queue)
1241 : : {
1242 : 0 : struct Qdisc *qdisc = dev_queue->qdisc_sleeping;
1243 : 0 : const struct Qdisc_ops *ops = qdisc->ops;
1244 : :
1245 : 0 : if (ops->change_tx_queue_len)
1246 : 0 : return ops->change_tx_queue_len(qdisc, dev->tx_queue_len);
1247 : : return 0;
1248 : : }
1249 : :
1250 : 0 : int dev_qdisc_change_tx_queue_len(struct net_device *dev)
1251 : : {
1252 : 0 : bool up = dev->flags & IFF_UP;
1253 : : unsigned int i;
1254 : : int ret = 0;
1255 : :
1256 : 0 : if (up)
1257 : 0 : dev_deactivate(dev);
1258 : :
1259 : 0 : for (i = 0; i < dev->num_tx_queues; i++) {
1260 : 0 : ret = qdisc_change_tx_queue_len(dev, &dev->_tx[i]);
1261 : :
1262 : : /* TODO: revert changes on a partial failure */
1263 : 0 : if (ret)
1264 : : break;
1265 : : }
1266 : :
1267 : 0 : if (up)
1268 : 0 : dev_activate(dev);
1269 : 0 : return ret;
1270 : : }
1271 : :
1272 : 3 : static void dev_init_scheduler_queue(struct net_device *dev,
1273 : : struct netdev_queue *dev_queue,
1274 : : void *_qdisc)
1275 : : {
1276 : : struct Qdisc *qdisc = _qdisc;
1277 : :
1278 : 3 : rcu_assign_pointer(dev_queue->qdisc, qdisc);
1279 : 3 : dev_queue->qdisc_sleeping = qdisc;
1280 : 3 : }
1281 : :
1282 : 3 : void dev_init_scheduler(struct net_device *dev)
1283 : : {
1284 : 3 : dev->qdisc = &noop_qdisc;
1285 : : netdev_for_each_tx_queue(dev, dev_init_scheduler_queue, &noop_qdisc);
1286 : 3 : if (dev_ingress_queue(dev))
1287 : : dev_init_scheduler_queue(dev, dev_ingress_queue(dev), &noop_qdisc);
1288 : :
1289 : 3 : timer_setup(&dev->watchdog_timer, dev_watchdog, 0);
1290 : 3 : }
1291 : :
1292 : 1 : static void shutdown_scheduler_queue(struct net_device *dev,
1293 : : struct netdev_queue *dev_queue,
1294 : : void *_qdisc_default)
1295 : : {
1296 : 1 : struct Qdisc *qdisc = dev_queue->qdisc_sleeping;
1297 : : struct Qdisc *qdisc_default = _qdisc_default;
1298 : :
1299 : 1 : if (qdisc) {
1300 : 1 : rcu_assign_pointer(dev_queue->qdisc, qdisc_default);
1301 : 1 : dev_queue->qdisc_sleeping = qdisc_default;
1302 : :
1303 : 1 : qdisc_put(qdisc);
1304 : : }
1305 : 1 : }
1306 : :
1307 : 1 : void dev_shutdown(struct net_device *dev)
1308 : : {
1309 : : netdev_for_each_tx_queue(dev, shutdown_scheduler_queue, &noop_qdisc);
1310 : 1 : if (dev_ingress_queue(dev))
1311 : : shutdown_scheduler_queue(dev, dev_ingress_queue(dev), &noop_qdisc);
1312 : 1 : qdisc_put(dev->qdisc);
1313 : 1 : dev->qdisc = &noop_qdisc;
1314 : :
1315 : 1 : WARN_ON(timer_pending(&dev->watchdog_timer));
1316 : 1 : }
1317 : :
1318 : 0 : void psched_ratecfg_precompute(struct psched_ratecfg *r,
1319 : : const struct tc_ratespec *conf,
1320 : : u64 rate64)
1321 : : {
1322 : 0 : memset(r, 0, sizeof(*r));
1323 : 0 : r->overhead = conf->overhead;
1324 : 0 : r->rate_bytes_ps = max_t(u64, conf->rate, rate64);
1325 : 0 : r->linklayer = (conf->linklayer & TC_LINKLAYER_MASK);
1326 : 0 : r->mult = 1;
1327 : : /*
1328 : : * The deal here is to replace a divide by a reciprocal one
1329 : : * in fast path (a reciprocal divide is a multiply and a shift)
1330 : : *
1331 : : * Normal formula would be :
1332 : : * time_in_ns = (NSEC_PER_SEC * len) / rate_bps
1333 : : *
1334 : : * We compute mult/shift to use instead :
1335 : : * time_in_ns = (len * mult) >> shift;
1336 : : *
1337 : : * We try to get the highest possible mult value for accuracy,
1338 : : * but have to make sure no overflows will ever happen.
1339 : : */
1340 : 0 : if (r->rate_bytes_ps > 0) {
1341 : : u64 factor = NSEC_PER_SEC;
1342 : :
1343 : : for (;;) {
1344 : 0 : r->mult = div64_u64(factor, r->rate_bytes_ps);
1345 : 0 : if (r->mult & (1U << 31) || factor & (1ULL << 63))
1346 : : break;
1347 : 0 : factor <<= 1;
1348 : 0 : r->shift++;
1349 : 0 : }
1350 : : }
1351 : 0 : }
1352 : : EXPORT_SYMBOL(psched_ratecfg_precompute);
1353 : :
1354 : 0 : static void mini_qdisc_rcu_func(struct rcu_head *head)
1355 : : {
1356 : 0 : }
1357 : :
1358 : 0 : void mini_qdisc_pair_swap(struct mini_Qdisc_pair *miniqp,
1359 : : struct tcf_proto *tp_head)
1360 : : {
1361 : : /* Protected with chain0->filter_chain_lock.
1362 : : * Can't access chain directly because tp_head can be NULL.
1363 : : */
1364 : : struct mini_Qdisc *miniq_old =
1365 : 0 : rcu_dereference_protected(*miniqp->p_miniq, 1);
1366 : : struct mini_Qdisc *miniq;
1367 : :
1368 : 0 : if (!tp_head) {
1369 : : RCU_INIT_POINTER(*miniqp->p_miniq, NULL);
1370 : : /* Wait for flying RCU callback before it is freed. */
1371 : 0 : rcu_barrier();
1372 : 0 : return;
1373 : : }
1374 : :
1375 : 0 : miniq = !miniq_old || miniq_old == &miniqp->miniq2 ?
1376 : 0 : &miniqp->miniq1 : &miniqp->miniq2;
1377 : :
1378 : : /* We need to make sure that readers won't see the miniq
1379 : : * we are about to modify. So wait until previous call_rcu callback
1380 : : * is done.
1381 : : */
1382 : 0 : rcu_barrier();
1383 : 0 : miniq->filter_list = tp_head;
1384 : 0 : rcu_assign_pointer(*miniqp->p_miniq, miniq);
1385 : :
1386 : 0 : if (miniq_old)
1387 : : /* This is counterpart of the rcu barriers above. We need to
1388 : : * block potential new user of miniq_old until all readers
1389 : : * are not seeing it.
1390 : : */
1391 : 0 : call_rcu(&miniq_old->rcu, mini_qdisc_rcu_func);
1392 : : }
1393 : : EXPORT_SYMBOL(mini_qdisc_pair_swap);
1394 : :
1395 : 0 : void mini_qdisc_pair_init(struct mini_Qdisc_pair *miniqp, struct Qdisc *qdisc,
1396 : : struct mini_Qdisc __rcu **p_miniq)
1397 : : {
1398 : 0 : miniqp->miniq1.cpu_bstats = qdisc->cpu_bstats;
1399 : 0 : miniqp->miniq1.cpu_qstats = qdisc->cpu_qstats;
1400 : 0 : miniqp->miniq2.cpu_bstats = qdisc->cpu_bstats;
1401 : 0 : miniqp->miniq2.cpu_qstats = qdisc->cpu_qstats;
1402 : 0 : miniqp->p_miniq = p_miniq;
1403 : 0 : }
1404 : : EXPORT_SYMBOL(mini_qdisc_pair_init);
|
