forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2023-12-11 072de836f53be56a70cecf70b43ae43b7ce17376 
 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 
....@@ -648,14 +650,14 @@
648650 
649651 	err = skb_array_produce(q, skb);
650652 
651
-	if (unlikely(err))
652
-		return qdisc_drop_cpu(skb, qdisc, to_free);
653
+	if (unlikely(err)) {
654
+		if (qdisc_is_percpu_stats(qdisc))
655
+			return qdisc_drop_cpu(skb, qdisc, to_free);
656
+		else
657
+			return qdisc_drop(skb, qdisc, to_free);
658
+	}
653659 
654
-	qdisc_qstats_atomic_qlen_inc(qdisc);
655
-	/* Note: skb can not be used after skb_array_produce(),
656
-	 * so we better not use qdisc_qstats_cpu_backlog_inc()
657
-	 */
658
-	this_cpu_add(qdisc->cpu_qstats->backlog, pkt_len);
660
+	qdisc_update_stats_at_enqueue(qdisc, pkt_len);
659661 	return NET_XMIT_SUCCESS;
660662 }
661663 
....@@ -663,8 +665,10 @@
663665 {
664666 	struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
665667 	struct sk_buff *skb = NULL;
668
+	bool need_retry = true;
666669 	int band;
667670 
671
+retry:
668672 	for (band = 0; band < PFIFO_FAST_BANDS && !skb; band++) {
669673 		struct skb_array *q = band2list(priv, band);
670674 
....@@ -674,9 +678,26 @@
674678 		skb = __skb_array_consume(q);
675679 	}
676680 	if (likely(skb)) {
677
-		qdisc_qstats_cpu_backlog_dec(qdisc, skb);
678
-		qdisc_bstats_cpu_update(qdisc, skb);
679
-		qdisc_qstats_atomic_qlen_dec(qdisc);
681
+		qdisc_update_stats_at_dequeue(qdisc, skb);
682
+	} else if (need_retry &&
683
+		   test_bit(__QDISC_STATE_MISSED, &qdisc->state)) {
684
+		/* Delay clearing the STATE_MISSED here to reduce
685
+		 * the overhead of the second spin_trylock() in
686
+		 * qdisc_run_begin() and __netif_schedule() calling
687
+		 * in qdisc_run_end().
688
+		 */
689
+		clear_bit(__QDISC_STATE_MISSED, &qdisc->state);
690
+
691
+		/* Make sure dequeuing happens after clearing
692
+		 * STATE_MISSED.
693
+		 */
694
+		smp_mb__after_atomic();
695
+
696
+		need_retry = false;
697
+
698
+		goto retry;
699
+	} else {
700
+		WRITE_ONCE(qdisc->empty, true);
680701 	}
681702 
682703 	return skb;
....@@ -716,10 +737,14 @@
716737 			kfree_skb(skb);
717738 	}
718739 
719
-	for_each_possible_cpu(i) {
720
-		struct gnet_stats_queue *q = per_cpu_ptr(qdisc->cpu_qstats, i);
740
+	if (qdisc_is_percpu_stats(qdisc)) {
741
+		for_each_possible_cpu(i) {
742
+			struct gnet_stats_queue *q;
721743 
722
-		q->backlog = 0;
744
+			q = per_cpu_ptr(qdisc->cpu_qstats, i);
745
+			q->backlog = 0;
746
+			q->qlen = 0;
747
+		}
723748 	}
724749 }
725750 
....@@ -821,9 +846,8 @@
821846 			  const struct Qdisc_ops *ops,
822847 			  struct netlink_ext_ack *extack)
823848 {
824
-	void *p;
825849 	struct Qdisc *sch;
826
-	unsigned int size = QDISC_ALIGN(sizeof(*sch)) + ops->priv_size;
850
+	unsigned int size = sizeof(*sch) + ops->priv_size;
827851 	int err = -ENOBUFS;
828852 	struct net_device *dev;
829853 
....@@ -834,22 +858,10 @@
834858 	}
835859 
836860 	dev = dev_queue->dev;
837
-	p = kzalloc_node(size, GFP_KERNEL,
838
-			 netdev_queue_numa_node_read(dev_queue));
861
+	sch = kzalloc_node(size, GFP_KERNEL, netdev_queue_numa_node_read(dev_queue));
839862 
840
-	if (!p)
863
+	if (!sch)
841864 		goto errout;
842
-	sch = (struct Qdisc *) QDISC_ALIGN((unsigned long) p);
843
-	/* if we got non aligned memory, ask more and do alignment ourself */
844
-	if (sch != p) {
845
-		kfree(p);
846
-		p = kzalloc_node(size + QDISC_ALIGNTO - 1, GFP_KERNEL,
847
-				 netdev_queue_numa_node_read(dev_queue));
848
-		if (!p)
849
-			goto errout;
850
-		sch = (struct Qdisc *) QDISC_ALIGN((unsigned long) p);
851
-		sch->padded = (char *) sch - (char *) p;
852
-	}
853865 	__skb_queue_head_init(&sch->gso_skb);
854866 	__skb_queue_head_init(&sch->skb_bad_txq);
855867 	qdisc_skb_head_init(&sch->q);
....@@ -874,7 +886,7 @@
874886 
875887 	/* seqlock has the same scope of busylock, for NOLOCK qdisc */
876888 	spin_lock_init(&sch->seqlock);
877
-	lockdep_set_class(&sch->busylock,
889
+	lockdep_set_class(&sch->seqlock,
878890 			  dev->qdisc_tx_busylock ?: &qdisc_tx_busylock);
879891 
880892 	seqcount_init(&sch->running);
....@@ -886,12 +898,13 @@
886898 	sch->enqueue = ops->enqueue;
887899 	sch->dequeue = ops->dequeue;
888900 	sch->dev_queue = dev_queue;
901
+	sch->empty = true;
889902 	dev_hold(dev);
890903 	refcount_set(&sch->refcnt, 1);
891904 
892905 	return sch;
893906 errout1:
894
-	kfree(p);
907
+	kfree(sch);
895908 errout:
896909 	return ERR_PTR(err);
897910 }
....@@ -915,8 +928,10 @@
915928 	}
916929 	sch->parent = parentid;
917930 
918
-	if (!ops->init || ops->init(sch, NULL, extack) == 0)
931
+	if (!ops->init || ops->init(sch, NULL, extack) == 0) {
932
+		trace_qdisc_create(ops, dev_queue->dev, parentid);
919933 		return sch;
934
+	}
920935 
921936 	qdisc_put(sch);
922937 	return NULL;
....@@ -929,6 +944,8 @@
929944 {
930945 	const struct Qdisc_ops *ops = qdisc->ops;
931946 	struct sk_buff *skb, *tmp;
947
+
948
+	trace_qdisc_reset(qdisc);
932949 
933950 	if (ops->reset)
934951 		ops->reset(qdisc);
....@@ -955,7 +972,7 @@
955972 		free_percpu(qdisc->cpu_qstats);
956973 	}
957974 
958
-	kfree((char *) qdisc - qdisc->padded);
975
+	kfree(qdisc);
959976 }
960977 
961978 static void qdisc_free_cb(struct rcu_head *head)
....@@ -967,12 +984,7 @@
967984 
968985 static void qdisc_destroy(struct Qdisc *qdisc)
969986 {
970
-	const struct Qdisc_ops *ops;
971
-	struct sk_buff *skb, *tmp;
972
-
973
-	if (!qdisc)
974
-		return;
975
-	ops = qdisc->ops;
987
+	const struct Qdisc_ops  *ops = qdisc->ops;
976988 
977989 #ifdef CONFIG_NET_SCHED
978990 	qdisc_hash_del(qdisc);
....@@ -980,29 +992,25 @@
980992 	qdisc_put_stab(rtnl_dereference(qdisc->stab));
981993 #endif
982994 	gen_kill_estimator(&qdisc->rate_est);
983
-	if (ops->reset)
984
-		ops->reset(qdisc);
995
+
996
+	qdisc_reset(qdisc);
997
+
985998 	if (ops->destroy)
986999 		ops->destroy(qdisc);
9871000 
9881001 	module_put(ops->owner);
9891002 	dev_put(qdisc_dev(qdisc));
9901003 
991
-	skb_queue_walk_safe(&qdisc->gso_skb, skb, tmp) {
992
-		__skb_unlink(skb, &qdisc->gso_skb);
993
-		kfree_skb_list(skb);
994
-	}
995
-
996
-	skb_queue_walk_safe(&qdisc->skb_bad_txq, skb, tmp) {
997
-		__skb_unlink(skb, &qdisc->skb_bad_txq);
998
-		kfree_skb_list(skb);
999
-	}
1004
+	trace_qdisc_destroy(qdisc);
10001005 
10011006 	call_rcu(&qdisc->rcu, qdisc_free_cb);
10021007 }
10031008 
10041009 void qdisc_put(struct Qdisc *qdisc)
10051010 {
1011
+	if (!qdisc)
1012
+		return;
1013
+
10061014 	if (qdisc->flags & TCQ_F_BUILTIN ||
10071015 	    !refcount_dec_and_test(&qdisc->refcnt))
10081016 		return;
....@@ -1049,6 +1057,21 @@
10491057 }
10501058 EXPORT_SYMBOL(dev_graft_qdisc);
10511059 
1060
+static void shutdown_scheduler_queue(struct net_device *dev,
1061
+				     struct netdev_queue *dev_queue,
1062
+				     void *_qdisc_default)
1063
+{
1064
+	struct Qdisc *qdisc = dev_queue->qdisc_sleeping;
1065
+	struct Qdisc *qdisc_default = _qdisc_default;
1066
+
1067
+	if (qdisc) {
1068
+		rcu_assign_pointer(dev_queue->qdisc, qdisc_default);
1069
+		dev_queue->qdisc_sleeping = qdisc_default;
1070
+
1071
+		qdisc_put(qdisc);
1072
+	}
1073
+}
1074
+
10521075 static void attach_one_default_qdisc(struct net_device *dev,
10531076 				     struct netdev_queue *dev_queue,
10541077 				     void *_unused)
....@@ -1058,12 +1081,13 @@
10581081 
10591082 	if (dev->priv_flags & IFF_NO_QUEUE)
10601083 		ops = &noqueue_qdisc_ops;
1084
+	else if(dev->type == ARPHRD_CAN)
1085
+		ops = &pfifo_fast_ops;
10611086 
10621087 	qdisc = qdisc_create_dflt(dev_queue, ops, TC_H_ROOT, NULL);
1063
-	if (!qdisc) {
1064
-		netdev_info(dev, "activation failed\n");
1088
+	if (!qdisc)
10651089 		return;
1066
-	}
1090
+
10671091 	if (!netif_is_multiqueue(dev))
10681092 		qdisc->flags |= TCQ_F_ONETXQUEUE | TCQ_F_NOPARENT;
10691093 	dev_queue->qdisc_sleeping = qdisc;
....@@ -1079,18 +1103,34 @@
10791103 	if (!netif_is_multiqueue(dev) ||
10801104 	    dev->priv_flags & IFF_NO_QUEUE) {
10811105 		netdev_for_each_tx_queue(dev, attach_one_default_qdisc, NULL);
1082
-		dev->qdisc = txq->qdisc_sleeping;
1083
-		qdisc_refcount_inc(dev->qdisc);
1106
+		qdisc = txq->qdisc_sleeping;
1107
+		rcu_assign_pointer(dev->qdisc, qdisc);
1108
+		qdisc_refcount_inc(qdisc);
10841109 	} else {
10851110 		qdisc = qdisc_create_dflt(txq, &mq_qdisc_ops, TC_H_ROOT, NULL);
10861111 		if (qdisc) {
1087
-			dev->qdisc = qdisc;
1112
+			rcu_assign_pointer(dev->qdisc, qdisc);
10881113 			qdisc->ops->attach(qdisc);
10891114 		}
10901115 	}
1116
+	qdisc = rtnl_dereference(dev->qdisc);
1117
+
1118
+	/* Detect default qdisc setup/init failed and fallback to "noqueue" */
1119
+	if (qdisc == &noop_qdisc) {
1120
+		netdev_warn(dev, "default qdisc (%s) fail, fallback to %s\n",
1121
+			    default_qdisc_ops->id, noqueue_qdisc_ops.id);
1122
+		netdev_for_each_tx_queue(dev, shutdown_scheduler_queue, &noop_qdisc);
1123
+		dev->priv_flags |= IFF_NO_QUEUE;
1124
+		netdev_for_each_tx_queue(dev, attach_one_default_qdisc, NULL);
1125
+		qdisc = txq->qdisc_sleeping;
1126
+		rcu_assign_pointer(dev->qdisc, qdisc);
1127
+		qdisc_refcount_inc(qdisc);
1128
+		dev->priv_flags ^= IFF_NO_QUEUE;
1129
+	}
1130
+
10911131 #ifdef CONFIG_NET_SCHED
1092
-	if (dev->qdisc != &noop_qdisc)
1093
-		qdisc_hash_add(dev->qdisc, false);
1132
+	if (qdisc != &noop_qdisc)
1133
+		qdisc_hash_add(qdisc, false);
10941134 #endif
10951135 }
10961136 
....@@ -1120,7 +1160,7 @@
11201160 	 * and noqueue_qdisc for virtual interfaces
11211161 	 */
11221162 
1123
-	if (dev->qdisc == &noop_qdisc)
1163
+	if (rtnl_dereference(dev->qdisc) == &noop_qdisc)
11241164 		attach_default_qdiscs(dev);
11251165 
11261166 	if (!netif_carrier_ok(dev))
....@@ -1139,17 +1179,24 @@
11391179 }
11401180 EXPORT_SYMBOL(dev_activate);
11411181 
1182
+static void qdisc_deactivate(struct Qdisc *qdisc)
1183
+{
1184
+	if (qdisc->flags & TCQ_F_BUILTIN)
1185
+		return;
1186
+
1187
+	set_bit(__QDISC_STATE_DEACTIVATED, &qdisc->state);
1188
+}
1189
+
11421190 static void dev_deactivate_queue(struct net_device *dev,
11431191 				 struct netdev_queue *dev_queue,
11441192 				 void *_qdisc_default)
11451193 {
1146
-	struct Qdisc *qdisc = rtnl_dereference(dev_queue->qdisc);
11471194 	struct Qdisc *qdisc_default = _qdisc_default;
1195
+	struct Qdisc *qdisc;
11481196 
1197
+	qdisc = rtnl_dereference(dev_queue->qdisc);
11491198 	if (qdisc) {
1150
-		if (!(qdisc->flags & TCQ_F_BUILTIN))
1151
-			set_bit(__QDISC_STATE_DEACTIVATED, &qdisc->state);
1152
-
1199
+		qdisc_deactivate(qdisc);
11531200 		rcu_assign_pointer(dev_queue->qdisc, qdisc_default);
11541201 	}
11551202 }
....@@ -1174,8 +1221,10 @@
11741221 	qdisc_reset(qdisc);
11751222 
11761223 	spin_unlock_bh(qdisc_lock(qdisc));
1177
-	if (nolock)
1224
+	if (nolock) {
1225
+		clear_bit(__QDISC_STATE_MISSED, &qdisc->state);
11781226 		spin_unlock_bh(&qdisc->seqlock);
1227
+	}
11791228 }
11801229 
11811230 static bool some_qdisc_is_busy(struct net_device *dev)
....@@ -1203,16 +1252,6 @@
12031252 			return true;
12041253 	}
12051254 	return false;
1206
-}
1207
-
1208
-static void dev_qdisc_reset(struct net_device *dev,
1209
-			    struct netdev_queue *dev_queue,
1210
-			    void *none)
1211
-{
1212
-	struct Qdisc *qdisc = dev_queue->qdisc_sleeping;
1213
-
1214
-	if (qdisc)
1215
-		qdisc_reset(qdisc);
12161255 }
12171256 
12181257 /**
....@@ -1252,14 +1291,13 @@
12521291 
12531292 	/* Wait for outstanding qdisc_run calls. */
12541293 	list_for_each_entry(dev, head, close_list) {
1255
-		while (some_qdisc_is_busy(dev))
1256
-			yield();
1257
-		/* The new qdisc is assigned at this point so we can safely
1258
-		 * unwind stale skb lists and qdisc statistics
1259
-		 */
1260
-		netdev_for_each_tx_queue(dev, dev_qdisc_reset, NULL);
1261
-		if (dev_ingress_queue(dev))
1262
-			dev_qdisc_reset(dev, dev_ingress_queue(dev), NULL);
1294
+		while (some_qdisc_is_busy(dev)) {
1295
+			/* wait_event() would avoid this sleep-loop but would
1296
+			 * require expensive checks in the fast paths of packet
1297
+			 * processing which isn't worth it.
1298
+			 */
1299
+			schedule_timeout_uninterruptible(1);
1300
+		}
12631301 	}
12641302 }
12651303 
....@@ -1318,7 +1356,7 @@
13181356 
13191357 void dev_init_scheduler(struct net_device *dev)
13201358 {
1321
-	dev->qdisc = &noop_qdisc;
1359
+	rcu_assign_pointer(dev->qdisc, &noop_qdisc);
13221360 	netdev_for_each_tx_queue(dev, dev_init_scheduler_queue, &noop_qdisc);
13231361 	if (dev_ingress_queue(dev))
13241362 		dev_init_scheduler_queue(dev, dev_ingress_queue(dev), &noop_qdisc);
....@@ -1326,28 +1364,13 @@
13261364 	timer_setup(&dev->watchdog_timer, dev_watchdog, 0);
13271365 }
13281366 
1329
-static void shutdown_scheduler_queue(struct net_device *dev,
1330
-				     struct netdev_queue *dev_queue,
1331
-				     void *_qdisc_default)
1332
-{
1333
-	struct Qdisc *qdisc = dev_queue->qdisc_sleeping;
1334
-	struct Qdisc *qdisc_default = _qdisc_default;
1335
-
1336
-	if (qdisc) {
1337
-		rcu_assign_pointer(dev_queue->qdisc, qdisc_default);
1338
-		dev_queue->qdisc_sleeping = qdisc_default;
1339
-
1340
-		qdisc_put(qdisc);
1341
-	}
1342
-}
1343
-
13441367 void dev_shutdown(struct net_device *dev)
13451368 {
13461369 	netdev_for_each_tx_queue(dev, shutdown_scheduler_queue, &noop_qdisc);
13471370 	if (dev_ingress_queue(dev))
13481371 		shutdown_scheduler_queue(dev, dev_ingress_queue(dev), &noop_qdisc);
1349
-	qdisc_put(dev->qdisc);
1350
-	dev->qdisc = &noop_qdisc;
1372
+	qdisc_put(rtnl_dereference(dev->qdisc));
1373
+	rcu_assign_pointer(dev->qdisc, &noop_qdisc);
13511374 
13521375 	WARN_ON(timer_pending(&dev->watchdog_timer));
13531376 }
....@@ -1396,13 +1419,17 @@
13961419 void mini_qdisc_pair_swap(struct mini_Qdisc_pair *miniqp,
13971420 			  struct tcf_proto *tp_head)
13981421 {
1399
-	struct mini_Qdisc *miniq_old = rtnl_dereference(*miniqp->p_miniq);
1422
+	/* Protected with chain0->filter_chain_lock.
1423
+	 * Can't access chain directly because tp_head can be NULL.
1424
+	 */
1425
+	struct mini_Qdisc *miniq_old =
1426
+		rcu_dereference_protected(*miniqp->p_miniq, 1);
14001427 	struct mini_Qdisc *miniq;
14011428 
14021429 	if (!tp_head) {
14031430 		RCU_INIT_POINTER(*miniqp->p_miniq, NULL);
14041431 		/* Wait for flying RCU callback before it is freed. */
1405
-		rcu_barrier_bh();
1432
+		rcu_barrier();
14061433 		return;
14071434 	}
14081435 
....@@ -1410,10 +1437,10 @@
14101437 		&miniqp->miniq1 : &miniqp->miniq2;
14111438 
14121439 	/* We need to make sure that readers won't see the miniq
1413
-	 * we are about to modify. So wait until previous call_rcu_bh callback
1440
+	 * we are about to modify. So wait until previous call_rcu callback
14141441 	 * is done.
14151442 	 */
1416
-	rcu_barrier_bh();
1443
+	rcu_barrier();
14171444 	miniq->filter_list = tp_head;
14181445 	rcu_assign_pointer(*miniqp->p_miniq, miniq);
14191446 
....@@ -1422,10 +1449,18 @@
14221449 		 * block potential new user of miniq_old until all readers
14231450 		 * are not seeing it.
14241451 		 */
1425
-		call_rcu_bh(&miniq_old->rcu, mini_qdisc_rcu_func);
1452
+		call_rcu(&miniq_old->rcu, mini_qdisc_rcu_func);
14261453 }
14271454 EXPORT_SYMBOL(mini_qdisc_pair_swap);
14281455 
1456
+void mini_qdisc_pair_block_init(struct mini_Qdisc_pair *miniqp,
1457
+				struct tcf_block *block)
1458
+{
1459
+	miniqp->miniq1.block = block;
1460
+	miniqp->miniq2.block = block;
1461
+}
1462
+EXPORT_SYMBOL(mini_qdisc_pair_block_init);
1463
+
14291464 void mini_qdisc_pair_init(struct mini_Qdisc_pair *miniqp, struct Qdisc *qdisc,
14301465 			  struct mini_Qdisc __rcu **p_miniq)
14311466 {