LCOV - code coverage report
Current view: top level - net/sched - sch_generic.c (source / functions) Hit Total Coverage
Test: Real Lines: 284 483 58.8 %
Date: 2020-10-17 15:46:16 Functions: 12 53 22.6 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14