LCOV - code coverage report
Current view: top level - net/sched - sch_generic.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 99 663 14.9 %
Date: 2022-03-28 15:32:58 Functions: 10 52 19.2 %
Branches: 28 388 7.2 %

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

Generated by: LCOV version 1.14