forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2023-12-08 01573e231f18eb2d99162747186f59511f56b64d 
 kernel/net/sched/sch_generic.c
....@@ -1,10 +1,6 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
12 /*
23  * net/sched/sch_generic.c	Generic packet scheduler routines.
3
- *
4
- *		This program is free software; you can redistribute it and/or
5
- *		modify it under the terms of the GNU General Public License
6
- *		as published by the Free Software Foundation; either version
7
- *		2 of the License, or (at your option) any later version.
84  *
95  * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
106  *              Jamal Hadi Salim, <hadi@cyberus.ca> 990601
....@@ -32,11 +28,31 @@
3228 #include <net/pkt_sched.h>
3329 #include <net/dst.h>
3430 #include <trace/events/qdisc.h>
31
+#include <trace/events/net.h>
3532 #include <net/xfrm.h>
3633 
3734 /* Qdisc to use by default */
3835 const struct Qdisc_ops *default_qdisc_ops = &pfifo_fast_ops;
3936 EXPORT_SYMBOL(default_qdisc_ops);
37
+
38
+static void qdisc_maybe_clear_missed(struct Qdisc *q,
39
+				     const struct netdev_queue *txq)
40
+{
41
+	clear_bit(__QDISC_STATE_MISSED, &q->state);
42
+
43
+	/* Make sure the below netif_xmit_frozen_or_stopped()
44
+	 * checking happens after clearing STATE_MISSED.
45
+	 */
46
+	smp_mb__after_atomic();
47
+
48
+	/* Checking netif_xmit_frozen_or_stopped() again to
49
+	 * make sure STATE_MISSED is set if the STATE_MISSED
50
+	 * set by netif_tx_wake_queue()'s rescheduling of
51
+	 * net_tx_action() is cleared by the above clear_bit().
52
+	 */
53
+	if (!netif_xmit_frozen_or_stopped(txq))
54
+		set_bit(__QDISC_STATE_MISSED, &q->state);
55
+}
4056 
4157 /* Main transmission queue. */
4258 
....@@ -70,13 +86,14 @@
7086 			skb = __skb_dequeue(&q->skb_bad_txq);
7187 			if (qdisc_is_percpu_stats(q)) {
7288 				qdisc_qstats_cpu_backlog_dec(q, skb);
73
-				qdisc_qstats_atomic_qlen_dec(q);
89
+				qdisc_qstats_cpu_qlen_dec(q);
7490 			} else {
7591 				qdisc_qstats_backlog_dec(q, skb);
7692 				q->q.qlen--;
7793 			}
7894 		} else {
7995 			skb = SKB_XOFF_MAGIC;
96
+			qdisc_maybe_clear_missed(q, txq);
8097 		}
8198 	}
8299 
....@@ -110,7 +127,7 @@
110127 
111128 	if (qdisc_is_percpu_stats(q)) {
112129 		qdisc_qstats_cpu_backlog_inc(q, skb);
113
-		qdisc_qstats_atomic_qlen_inc(q);
130
+		qdisc_qstats_cpu_qlen_inc(q);
114131 	} else {
115132 		qdisc_qstats_backlog_inc(q, skb);
116133 		q->q.qlen++;
....@@ -120,52 +137,36 @@
120137 		spin_unlock(lock);
121138 }
122139 
123
-static inline int __dev_requeue_skb(struct sk_buff *skb, struct Qdisc *q)
140
+static inline void dev_requeue_skb(struct sk_buff *skb, struct Qdisc *q)
124141 {
125
-	while (skb) {
126
-		struct sk_buff *next = skb->next;
142
+	spinlock_t *lock = NULL;
127143 
128
-		__skb_queue_tail(&q->gso_skb, skb);
129
-		q->qstats.requeues++;
130
-		qdisc_qstats_backlog_inc(q, skb);
131
-		q->q.qlen++;	/* it's still part of the queue */
132
-
133
-		skb = next;
144
+	if (q->flags & TCQ_F_NOLOCK) {
145
+		lock = qdisc_lock(q);
146
+		spin_lock(lock);
134147 	}
135
-	__netif_schedule(q);
136148 
137
-	return 0;
138
-}
139
-
140
-static inline int dev_requeue_skb_locked(struct sk_buff *skb, struct Qdisc *q)
141
-{
142
-	spinlock_t *lock = qdisc_lock(q);
143
-
144
-	spin_lock(lock);
145149 	while (skb) {
146150 		struct sk_buff *next = skb->next;
147151 
148152 		__skb_queue_tail(&q->gso_skb, skb);
149153 
150
-		qdisc_qstats_cpu_requeues_inc(q);
151
-		qdisc_qstats_cpu_backlog_inc(q, skb);
152
-		qdisc_qstats_atomic_qlen_inc(q);
154
+		/* it's still part of the queue */
155
+		if (qdisc_is_percpu_stats(q)) {
156
+			qdisc_qstats_cpu_requeues_inc(q);
157
+			qdisc_qstats_cpu_backlog_inc(q, skb);
158
+			qdisc_qstats_cpu_qlen_inc(q);
159
+		} else {
160
+			q->qstats.requeues++;
161
+			qdisc_qstats_backlog_inc(q, skb);
162
+			q->q.qlen++;
163
+		}
153164 
154165 		skb = next;
155166 	}
156
-	spin_unlock(lock);
157
-
167
+	if (lock)
168
+		spin_unlock(lock);
158169 	__netif_schedule(q);
159
-
160
-	return 0;
161
-}
162
-
163
-static inline int dev_requeue_skb(struct sk_buff *skb, struct Qdisc *q)
164
-{
165
-	if (q->flags & TCQ_F_NOLOCK)
166
-		return dev_requeue_skb_locked(skb, q);
167
-	else
168
-		return __dev_requeue_skb(skb, q);
169170 }
170171 
171172 static void try_bulk_dequeue_skb(struct Qdisc *q,
....@@ -186,7 +187,7 @@
186187 		skb = nskb;
187188 		(*packets)++; /* GSO counts as one pkt */
188189 	}
189
-	skb->next = NULL;
190
+	skb_mark_not_on_list(skb);
190191 }
191192 
192193 /* This variant of try_bulk_dequeue_skb() makes sure
....@@ -212,7 +213,7 @@
212213 		skb = nskb;
213214 	} while (++cnt < 8);
214215 	(*packets) += cnt;
215
-	skb->next = NULL;
216
+	skb_mark_not_on_list(skb);
216217 }
217218 
218219 /* Note that dequeue_skb can possibly return a SKB list (via skb->next).
....@@ -254,13 +255,14 @@
254255 			skb = __skb_dequeue(&q->gso_skb);
255256 			if (qdisc_is_percpu_stats(q)) {
256257 				qdisc_qstats_cpu_backlog_dec(q, skb);
257
-				qdisc_qstats_atomic_qlen_dec(q);
258
+				qdisc_qstats_cpu_qlen_dec(q);
258259 			} else {
259260 				qdisc_qstats_backlog_dec(q, skb);
260261 				q->q.qlen--;
261262 			}
262263 		} else {
263264 			skb = NULL;
265
+			qdisc_maybe_clear_missed(q, txq);
264266 		}
265267 		if (lock)
266268 			spin_unlock(lock);
....@@ -270,8 +272,10 @@
270272 	*validate = true;
271273 
272274 	if ((q->flags & TCQ_F_ONETXQUEUE) &&
273
-	    netif_xmit_frozen_or_stopped(txq))
275
+	    netif_xmit_frozen_or_stopped(txq)) {
276
+		qdisc_maybe_clear_missed(q, txq);
274277 		return skb;
278
+	}
275279 
276280 	skb = qdisc_dequeue_skb_bad_txq(q);
277281 	if (unlikely(skb)) {
....@@ -330,6 +334,8 @@
330334 		HARD_TX_LOCK(dev, txq, smp_processor_id());
331335 		if (!netif_xmit_frozen_or_stopped(txq))
332336 			skb = dev_hard_start_xmit(skb, dev, txq, &ret);
337
+		else
338
+			qdisc_maybe_clear_missed(q, txq);
333339 
334340 		HARD_TX_UNLOCK(dev, txq);
335341 	} else {
....@@ -397,17 +403,12 @@
397403 
398404 void __qdisc_run(struct Qdisc *q)
399405 {
400
-	int quota = dev_tx_weight;
406
+	int quota = READ_ONCE(dev_tx_weight);
401407 	int packets;
402408 
403409 	while (qdisc_restart(q, &packets)) {
404
-		/*
405
-		 * Ordered by possible occurrence: Postpone processing if
406
-		 * 1. we've exceeded packet quota
407
-		 * 2. another process needs the CPU;
408
-		 */
409410 		quota -= packets;
410
-		if (quota <= 0 || need_resched()) {
411
+		if (quota <= 0) {
411412 			__netif_schedule(q);
412413 			break;
413414 		}
....@@ -462,9 +463,10 @@
462463 			}
463464 
464465 			if (some_queue_timedout) {
466
+				trace_net_dev_xmit_timeout(dev, i);
465467 				WARN_ONCE(1, KERN_INFO "NETDEV WATCHDOG: %s (%s): transmit queue %u timed out\n",
466468 				       dev->name, netdev_drivername(dev), i);
467
-				dev->netdev_ops->ndo_tx_timeout(dev);
469
+				dev->netdev_ops->ndo_tx_timeout(dev, i);
468470 			}
469471 			if (!mod_timer(&dev->watchdog_timer,
470472 				       round_jiffies(jiffies +
....@@ -506,7 +508,7 @@
506508  *	netif_carrier_on - set carrier
507509  *	@dev: network device
508510  *
509
- * Device has detected that carrier.
511
+ * Device has detected acquisition of carrier.
510512  */
511513 void netif_carrier_on(struct net_device *dev)
512514 {
....@@ -565,7 +567,7 @@
565567 };
566568 
567569 static struct netdev_queue noop_netdev_queue = {
568
-	.qdisc		=	&noop_qdisc,
570
+	RCU_POINTER_INITIALIZER(qdisc, &noop_qdisc),
569571 	.qdisc_sleeping	=	&noop_qdisc,
570572 };
571573 
....@@ -576,7 +578,7 @@
576578 	.ops		=	&noop_qdisc_ops,
577579 	.q.lock		=	__SPIN_LOCK_UNLOCKED(noop_qdisc.q.lock),
578580 	.dev_queue	=	&noop_netdev_queue,
579
-#ifdef CONFIG_PREEMPT_RT_BASE
581
+#ifdef CONFIG_PREEMPT_RT
580582 	.running	=	__SEQLOCK_UNLOCKED(noop_qdisc.running),
581583 #else
582584 	.running	=	SEQCNT_ZERO(noop_qdisc.running),
....@@ -652,14 +654,14 @@
652654 
653655 	err = skb_array_produce(q, skb);
654656 
655
-	if (unlikely(err))
656
-		return qdisc_drop_cpu(skb, qdisc, to_free);
657
+	if (unlikely(err)) {
658
+		if (qdisc_is_percpu_stats(qdisc))
659
+			return qdisc_drop_cpu(skb, qdisc, to_free);
660
+		else
661
+			return qdisc_drop(skb, qdisc, to_free);
662
+	}
657663 
658
-	qdisc_qstats_atomic_qlen_inc(qdisc);
659
-	/* Note: skb can not be used after skb_array_produce(),
660
-	 * so we better not use qdisc_qstats_cpu_backlog_inc()
661
-	 */
662
-	this_cpu_add(qdisc->cpu_qstats->backlog, pkt_len);
664
+	qdisc_update_stats_at_enqueue(qdisc, pkt_len);
663665 	return NET_XMIT_SUCCESS;
664666 }
665667 
....@@ -667,8 +669,10 @@
667669 {
668670 	struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
669671 	struct sk_buff *skb = NULL;
672
+	bool need_retry = true;
670673 	int band;
671674 
675
+retry:
672676 	for (band = 0; band < PFIFO_FAST_BANDS && !skb; band++) {
673677 		struct skb_array *q = band2list(priv, band);
674678 
....@@ -678,9 +682,26 @@
678682 		skb = __skb_array_consume(q);
679683 	}
680684 	if (likely(skb)) {
681
-		qdisc_qstats_cpu_backlog_dec(qdisc, skb);
682
-		qdisc_bstats_cpu_update(qdisc, skb);
683
-		qdisc_qstats_atomic_qlen_dec(qdisc);
685
+		qdisc_update_stats_at_dequeue(qdisc, skb);
686
+	} else if (need_retry &&
687
+		   test_bit(__QDISC_STATE_MISSED, &qdisc->state)) {
688
+		/* Delay clearing the STATE_MISSED here to reduce
689
+		 * the overhead of the second spin_trylock() in
690
+		 * qdisc_run_begin() and __netif_schedule() calling
691
+		 * in qdisc_run_end().
692
+		 */
693
+		clear_bit(__QDISC_STATE_MISSED, &qdisc->state);
694
+
695
+		/* Make sure dequeuing happens after clearing
696
+		 * STATE_MISSED.
697
+		 */
698
+		smp_mb__after_atomic();
699
+
700
+		need_retry = false;
701
+
702
+		goto retry;
703
+	} else {
704
+		WRITE_ONCE(qdisc->empty, true);
684705 	}
685706 
686707 	return skb;
....@@ -720,10 +741,14 @@
720741 			kfree_skb(skb);
721742 	}
722743 
723
-	for_each_possible_cpu(i) {
724
-		struct gnet_stats_queue *q = per_cpu_ptr(qdisc->cpu_qstats, i);
744
+	if (qdisc_is_percpu_stats(qdisc)) {
745
+		for_each_possible_cpu(i) {
746
+			struct gnet_stats_queue *q;
725747 
726
-		q->backlog = 0;
748
+			q = per_cpu_ptr(qdisc->cpu_qstats, i);
749
+			q->backlog = 0;
750
+			q->qlen = 0;
751
+		}
727752 	}
728753 }
729754 
....@@ -825,9 +850,8 @@
825850 			  const struct Qdisc_ops *ops,
826851 			  struct netlink_ext_ack *extack)
827852 {
828
-	void *p;
829853 	struct Qdisc *sch;
830
-	unsigned int size = QDISC_ALIGN(sizeof(*sch)) + ops->priv_size;
854
+	unsigned int size = sizeof(*sch) + ops->priv_size;
831855 	int err = -ENOBUFS;
832856 	struct net_device *dev;
833857 
....@@ -838,22 +862,10 @@
838862 	}
839863 
840864 	dev = dev_queue->dev;
841
-	p = kzalloc_node(size, GFP_KERNEL,
842
-			 netdev_queue_numa_node_read(dev_queue));
865
+	sch = kzalloc_node(size, GFP_KERNEL, netdev_queue_numa_node_read(dev_queue));
843866 
844
-	if (!p)
867
+	if (!sch)
845868 		goto errout;
846
-	sch = (struct Qdisc *) QDISC_ALIGN((unsigned long) p);
847
-	/* if we got non aligned memory, ask more and do alignment ourself */
848
-	if (sch != p) {
849
-		kfree(p);
850
-		p = kzalloc_node(size + QDISC_ALIGNTO - 1, GFP_KERNEL,
851
-				 netdev_queue_numa_node_read(dev_queue));
852
-		if (!p)
853
-			goto errout;
854
-		sch = (struct Qdisc *) QDISC_ALIGN((unsigned long) p);
855
-		sch->padded = (char *) sch - (char *) p;
856
-	}
857869 	__skb_queue_head_init(&sch->gso_skb);
858870 	__skb_queue_head_init(&sch->skb_bad_txq);
859871 	qdisc_skb_head_init(&sch->q);
....@@ -878,13 +890,11 @@
878890 
879891 	/* seqlock has the same scope of busylock, for NOLOCK qdisc */
880892 	spin_lock_init(&sch->seqlock);
881
-	lockdep_set_class(&sch->busylock,
893
+	lockdep_set_class(&sch->seqlock,
882894 			  dev->qdisc_tx_busylock ?: &qdisc_tx_busylock);
883895 
884
-#ifdef CONFIG_PREEMPT_RT_BASE
896
+#ifdef CONFIG_PREEMPT_RT
885897 	seqlock_init(&sch->running);
886
-	lockdep_set_class(&sch->running.seqcount,
887
-			  dev->qdisc_running_key ?: &qdisc_running_key);
888898 	lockdep_set_class(&sch->running.lock,
889899 			  dev->qdisc_running_key ?: &qdisc_running_key);
890900 #else
....@@ -898,12 +908,13 @@
898908 	sch->enqueue = ops->enqueue;
899909 	sch->dequeue = ops->dequeue;
900910 	sch->dev_queue = dev_queue;
911
+	sch->empty = true;
901912 	dev_hold(dev);
902913 	refcount_set(&sch->refcnt, 1);
903914 
904915 	return sch;
905916 errout1:
906
-	kfree(p);
917
+	kfree(sch);
907918 errout:
908919 	return ERR_PTR(err);
909920 }
....@@ -927,8 +938,10 @@
927938 	}
928939 	sch->parent = parentid;
929940 
930
-	if (!ops->init || ops->init(sch, NULL, extack) == 0)
941
+	if (!ops->init || ops->init(sch, NULL, extack) == 0) {
942
+		trace_qdisc_create(ops, dev_queue->dev, parentid);
931943 		return sch;
944
+	}
932945 
933946 	qdisc_put(sch);
934947 	return NULL;
....@@ -941,6 +954,8 @@
941954 {
942955 	const struct Qdisc_ops *ops = qdisc->ops;
943956 	struct sk_buff *skb, *tmp;
957
+
958
+	trace_qdisc_reset(qdisc);
944959 
945960 	if (ops->reset)
946961 		ops->reset(qdisc);
....@@ -967,7 +982,7 @@
967982 		free_percpu(qdisc->cpu_qstats);
968983 	}
969984 
970
-	kfree((char *) qdisc - qdisc->padded);
985
+	kfree(qdisc);
971986 }
972987 
973988 static void qdisc_free_cb(struct rcu_head *head)
....@@ -979,12 +994,7 @@
979994 
980995 static void qdisc_destroy(struct Qdisc *qdisc)
981996 {
982
-	const struct Qdisc_ops *ops;
983
-	struct sk_buff *skb, *tmp;
984
-
985
-	if (!qdisc)
986
-		return;
987
-	ops = qdisc->ops;
997
+	const struct Qdisc_ops  *ops = qdisc->ops;
988998 
989999 #ifdef CONFIG_NET_SCHED
9901000 	qdisc_hash_del(qdisc);
....@@ -992,29 +1002,25 @@
9921002 	qdisc_put_stab(rtnl_dereference(qdisc->stab));
9931003 #endif
9941004 	gen_kill_estimator(&qdisc->rate_est);
995
-	if (ops->reset)
996
-		ops->reset(qdisc);
1005
+
1006
+	qdisc_reset(qdisc);
1007
+
9971008 	if (ops->destroy)
9981009 		ops->destroy(qdisc);
9991010 
10001011 	module_put(ops->owner);
10011012 	dev_put(qdisc_dev(qdisc));
10021013 
1003
-	skb_queue_walk_safe(&qdisc->gso_skb, skb, tmp) {
1004
-		__skb_unlink(skb, &qdisc->gso_skb);
1005
-		kfree_skb_list(skb);
1006
-	}
1007
-
1008
-	skb_queue_walk_safe(&qdisc->skb_bad_txq, skb, tmp) {
1009
-		__skb_unlink(skb, &qdisc->skb_bad_txq);
1010
-		kfree_skb_list(skb);
1011
-	}
1014
+	trace_qdisc_destroy(qdisc);
10121015 
10131016 	call_rcu(&qdisc->rcu, qdisc_free_cb);
10141017 }
10151018 
10161019 void qdisc_put(struct Qdisc *qdisc)
10171020 {
1021
+	if (!qdisc)
1022
+		return;
1023
+
10181024 	if (qdisc->flags & TCQ_F_BUILTIN ||
10191025 	    !refcount_dec_and_test(&qdisc->refcnt))
10201026 		return;
....@@ -1061,6 +1067,21 @@
10611067 }
10621068 EXPORT_SYMBOL(dev_graft_qdisc);
10631069 
1070
+static void shutdown_scheduler_queue(struct net_device *dev,
1071
+				     struct netdev_queue *dev_queue,
1072
+				     void *_qdisc_default)
1073
+{
1074
+	struct Qdisc *qdisc = dev_queue->qdisc_sleeping;
1075
+	struct Qdisc *qdisc_default = _qdisc_default;
1076
+
1077
+	if (qdisc) {
1078
+		rcu_assign_pointer(dev_queue->qdisc, qdisc_default);
1079
+		dev_queue->qdisc_sleeping = qdisc_default;
1080
+
1081
+		qdisc_put(qdisc);
1082
+	}
1083
+}
1084
+
10641085 static void attach_one_default_qdisc(struct net_device *dev,
10651086 				     struct netdev_queue *dev_queue,
10661087 				     void *_unused)
....@@ -1070,12 +1091,13 @@
10701091 
10711092 	if (dev->priv_flags & IFF_NO_QUEUE)
10721093 		ops = &noqueue_qdisc_ops;
1094
+	else if(dev->type == ARPHRD_CAN)
1095
+		ops = &pfifo_fast_ops;
10731096 
10741097 	qdisc = qdisc_create_dflt(dev_queue, ops, TC_H_ROOT, NULL);
1075
-	if (!qdisc) {
1076
-		netdev_info(dev, "activation failed\n");
1098
+	if (!qdisc)
10771099 		return;
1078
-	}
1100
+
10791101 	if (!netif_is_multiqueue(dev))
10801102 		qdisc->flags |= TCQ_F_ONETXQUEUE | TCQ_F_NOPARENT;
10811103 	dev_queue->qdisc_sleeping = qdisc;
....@@ -1091,18 +1113,34 @@
10911113 	if (!netif_is_multiqueue(dev) ||
10921114 	    dev->priv_flags & IFF_NO_QUEUE) {
10931115 		netdev_for_each_tx_queue(dev, attach_one_default_qdisc, NULL);
1094
-		dev->qdisc = txq->qdisc_sleeping;
1095
-		qdisc_refcount_inc(dev->qdisc);
1116
+		qdisc = txq->qdisc_sleeping;
1117
+		rcu_assign_pointer(dev->qdisc, qdisc);
1118
+		qdisc_refcount_inc(qdisc);
10961119 	} else {
10971120 		qdisc = qdisc_create_dflt(txq, &mq_qdisc_ops, TC_H_ROOT, NULL);
10981121 		if (qdisc) {
1099
-			dev->qdisc = qdisc;
1122
+			rcu_assign_pointer(dev->qdisc, qdisc);
11001123 			qdisc->ops->attach(qdisc);
11011124 		}
11021125 	}
1126
+	qdisc = rtnl_dereference(dev->qdisc);
1127
+
1128
+	/* Detect default qdisc setup/init failed and fallback to "noqueue" */
1129
+	if (qdisc == &noop_qdisc) {
1130
+		netdev_warn(dev, "default qdisc (%s) fail, fallback to %s\n",
1131
+			    default_qdisc_ops->id, noqueue_qdisc_ops.id);
1132
+		netdev_for_each_tx_queue(dev, shutdown_scheduler_queue, &noop_qdisc);
1133
+		dev->priv_flags |= IFF_NO_QUEUE;
1134
+		netdev_for_each_tx_queue(dev, attach_one_default_qdisc, NULL);
1135
+		qdisc = txq->qdisc_sleeping;
1136
+		rcu_assign_pointer(dev->qdisc, qdisc);
1137
+		qdisc_refcount_inc(qdisc);
1138
+		dev->priv_flags ^= IFF_NO_QUEUE;
1139
+	}
1140
+
11031141 #ifdef CONFIG_NET_SCHED
1104
-	if (dev->qdisc != &noop_qdisc)
1105
-		qdisc_hash_add(dev->qdisc, false);
1142
+	if (qdisc != &noop_qdisc)
1143
+		qdisc_hash_add(qdisc, false);
11061144 #endif
11071145 }
11081146 
....@@ -1132,7 +1170,7 @@
11321170 	 * and noqueue_qdisc for virtual interfaces
11331171 	 */
11341172 
1135
-	if (dev->qdisc == &noop_qdisc)
1173
+	if (rtnl_dereference(dev->qdisc) == &noop_qdisc)
11361174 		attach_default_qdiscs(dev);
11371175 
11381176 	if (!netif_carrier_ok(dev))
....@@ -1151,17 +1189,24 @@
11511189 }
11521190 EXPORT_SYMBOL(dev_activate);
11531191 
1192
+static void qdisc_deactivate(struct Qdisc *qdisc)
1193
+{
1194
+	if (qdisc->flags & TCQ_F_BUILTIN)
1195
+		return;
1196
+
1197
+	set_bit(__QDISC_STATE_DEACTIVATED, &qdisc->state);
1198
+}
1199
+
11541200 static void dev_deactivate_queue(struct net_device *dev,
11551201 				 struct netdev_queue *dev_queue,
11561202 				 void *_qdisc_default)
11571203 {
1158
-	struct Qdisc *qdisc = rtnl_dereference(dev_queue->qdisc);
11591204 	struct Qdisc *qdisc_default = _qdisc_default;
1205
+	struct Qdisc *qdisc;
11601206 
1207
+	qdisc = rtnl_dereference(dev_queue->qdisc);
11611208 	if (qdisc) {
1162
-		if (!(qdisc->flags & TCQ_F_BUILTIN))
1163
-			set_bit(__QDISC_STATE_DEACTIVATED, &qdisc->state);
1164
-
1209
+		qdisc_deactivate(qdisc);
11651210 		rcu_assign_pointer(dev_queue->qdisc, qdisc_default);
11661211 	}
11671212 }
....@@ -1186,8 +1231,10 @@
11861231 	qdisc_reset(qdisc);
11871232 
11881233 	spin_unlock_bh(qdisc_lock(qdisc));
1189
-	if (nolock)
1234
+	if (nolock) {
1235
+		clear_bit(__QDISC_STATE_MISSED, &qdisc->state);
11901236 		spin_unlock_bh(&qdisc->seqlock);
1237
+	}
11911238 }
11921239 
11931240 static bool some_qdisc_is_busy(struct net_device *dev)
....@@ -1215,16 +1262,6 @@
12151262 			return true;
12161263 	}
12171264 	return false;
1218
-}
1219
-
1220
-static void dev_qdisc_reset(struct net_device *dev,
1221
-			    struct netdev_queue *dev_queue,
1222
-			    void *none)
1223
-{
1224
-	struct Qdisc *qdisc = dev_queue->qdisc_sleeping;
1225
-
1226
-	if (qdisc)
1227
-		qdisc_reset(qdisc);
12281265 }
12291266 
12301267 /**
....@@ -1264,14 +1301,13 @@
12641301 
12651302 	/* Wait for outstanding qdisc_run calls. */
12661303 	list_for_each_entry(dev, head, close_list) {
1267
-		while (some_qdisc_is_busy(dev))
1268
-			msleep(1);
1269
-		/* The new qdisc is assigned at this point so we can safely
1270
-		 * unwind stale skb lists and qdisc statistics
1271
-		 */
1272
-		netdev_for_each_tx_queue(dev, dev_qdisc_reset, NULL);
1273
-		if (dev_ingress_queue(dev))
1274
-			dev_qdisc_reset(dev, dev_ingress_queue(dev), NULL);
1304
+		while (some_qdisc_is_busy(dev)) {
1305
+			/* wait_event() would avoid this sleep-loop but would
1306
+			 * require expensive checks in the fast paths of packet
1307
+			 * processing which isn't worth it.
1308
+			 */
1309
+			schedule_timeout_uninterruptible(1);
1310
+		}
12751311 	}
12761312 }
12771313 
....@@ -1330,7 +1366,7 @@
13301366 
13311367 void dev_init_scheduler(struct net_device *dev)
13321368 {
1333
-	dev->qdisc = &noop_qdisc;
1369
+	rcu_assign_pointer(dev->qdisc, &noop_qdisc);
13341370 	netdev_for_each_tx_queue(dev, dev_init_scheduler_queue, &noop_qdisc);
13351371 	if (dev_ingress_queue(dev))
13361372 		dev_init_scheduler_queue(dev, dev_ingress_queue(dev), &noop_qdisc);
....@@ -1338,28 +1374,13 @@
13381374 	timer_setup(&dev->watchdog_timer, dev_watchdog, 0);
13391375 }
13401376 
1341
-static void shutdown_scheduler_queue(struct net_device *dev,
1342
-				     struct netdev_queue *dev_queue,
1343
-				     void *_qdisc_default)
1344
-{
1345
-	struct Qdisc *qdisc = dev_queue->qdisc_sleeping;
1346
-	struct Qdisc *qdisc_default = _qdisc_default;
1347
-
1348
-	if (qdisc) {
1349
-		rcu_assign_pointer(dev_queue->qdisc, qdisc_default);
1350
-		dev_queue->qdisc_sleeping = qdisc_default;
1351
-
1352
-		qdisc_put(qdisc);
1353
-	}
1354
-}
1355
-
13561377 void dev_shutdown(struct net_device *dev)
13571378 {
13581379 	netdev_for_each_tx_queue(dev, shutdown_scheduler_queue, &noop_qdisc);
13591380 	if (dev_ingress_queue(dev))
13601381 		shutdown_scheduler_queue(dev, dev_ingress_queue(dev), &noop_qdisc);
1361
-	qdisc_put(dev->qdisc);
1362
-	dev->qdisc = &noop_qdisc;
1382
+	qdisc_put(rtnl_dereference(dev->qdisc));
1383
+	rcu_assign_pointer(dev->qdisc, &noop_qdisc);
13631384 
13641385 	WARN_ON(timer_pending(&dev->watchdog_timer));
13651386 }
....@@ -1408,13 +1429,17 @@
14081429 void mini_qdisc_pair_swap(struct mini_Qdisc_pair *miniqp,
14091430 			  struct tcf_proto *tp_head)
14101431 {
1411
-	struct mini_Qdisc *miniq_old = rtnl_dereference(*miniqp->p_miniq);
1432
+	/* Protected with chain0->filter_chain_lock.
1433
+	 * Can't access chain directly because tp_head can be NULL.
1434
+	 */
1435
+	struct mini_Qdisc *miniq_old =
1436
+		rcu_dereference_protected(*miniqp->p_miniq, 1);
14121437 	struct mini_Qdisc *miniq;
14131438 
14141439 	if (!tp_head) {
14151440 		RCU_INIT_POINTER(*miniqp->p_miniq, NULL);
14161441 		/* Wait for flying RCU callback before it is freed. */
1417
-		rcu_barrier_bh();
1442
+		rcu_barrier();
14181443 		return;
14191444 	}
14201445 
....@@ -1422,10 +1447,10 @@
14221447 		&miniqp->miniq1 : &miniqp->miniq2;
14231448 
14241449 	/* We need to make sure that readers won't see the miniq
1425
-	 * we are about to modify. So wait until previous call_rcu_bh callback
1450
+	 * we are about to modify. So wait until previous call_rcu callback
14261451 	 * is done.
14271452 	 */
1428
-	rcu_barrier_bh();
1453
+	rcu_barrier();
14291454 	miniq->filter_list = tp_head;
14301455 	rcu_assign_pointer(*miniqp->p_miniq, miniq);
14311456 
....@@ -1434,10 +1459,18 @@
14341459 		 * block potential new user of miniq_old until all readers
14351460 		 * are not seeing it.
14361461 		 */
1437
-		call_rcu_bh(&miniq_old->rcu, mini_qdisc_rcu_func);
1462
+		call_rcu(&miniq_old->rcu, mini_qdisc_rcu_func);
14381463 }
14391464 EXPORT_SYMBOL(mini_qdisc_pair_swap);
14401465 
1466
+void mini_qdisc_pair_block_init(struct mini_Qdisc_pair *miniqp,
1467
+				struct tcf_block *block)
1468
+{
1469
+	miniqp->miniq1.block = block;
1470
+	miniqp->miniq2.block = block;
1471
+}
1472
+EXPORT_SYMBOL(mini_qdisc_pair_block_init);
1473
+
14411474 void mini_qdisc_pair_init(struct mini_Qdisc_pair *miniqp, struct Qdisc *qdisc,
14421475 			  struct mini_Qdisc __rcu **p_miniq)
14431476 {