Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  * Linux network device link state notification
       4                 :            :  *
       5                 :            :  * Author:
       6                 :            :  *     Stefan Rompf <sux@loplof.de>
       7                 :            :  */
       8                 :            : 
       9                 :            : #include <linux/module.h>
      10                 :            : #include <linux/netdevice.h>
      11                 :            : #include <linux/if.h>
      12                 :            : #include <net/sock.h>
      13                 :            : #include <net/pkt_sched.h>
      14                 :            : #include <linux/rtnetlink.h>
      15                 :            : #include <linux/jiffies.h>
      16                 :            : #include <linux/spinlock.h>
      17                 :            : #include <linux/workqueue.h>
      18                 :            : #include <linux/bitops.h>
      19                 :            : #include <linux/types.h>
      20                 :            : 
      21                 :            : 
      22                 :            : enum lw_bits {
      23                 :            :         LW_URGENT = 0,
      24                 :            : };
      25                 :            : 
      26                 :            : static unsigned long linkwatch_flags;
      27                 :            : static unsigned long linkwatch_nextevent;
      28                 :            : 
      29                 :            : static void linkwatch_event(struct work_struct *dummy);
      30                 :            : static DECLARE_DELAYED_WORK(linkwatch_work, linkwatch_event);
      31                 :            : 
      32                 :            : static LIST_HEAD(lweventlist);
      33                 :            : static DEFINE_SPINLOCK(lweventlist_lock);
      34                 :            : 
      35                 :         21 : static unsigned char default_operstate(const struct net_device *dev)
      36                 :            : {
      37         [ +  - ]:         21 :         if (!netif_carrier_ok(dev))
      38                 :         21 :                 return (dev->ifindex != dev_get_iflink(dev) ?
      39         [ +  - ]:         21 :                         IF_OPER_LOWERLAYERDOWN : IF_OPER_DOWN);
      40                 :            : 
      41         [ #  # ]:          0 :         if (netif_dormant(dev))
      42                 :          0 :                 return IF_OPER_DORMANT;
      43                 :            : 
      44                 :            :         return IF_OPER_UP;
      45                 :            : }
      46                 :            : 
      47                 :            : 
      48                 :         21 : static void rfc2863_policy(struct net_device *dev)
      49                 :            : {
      50                 :         21 :         unsigned char operstate = default_operstate(dev);
      51                 :            : 
      52         [ +  - ]:         21 :         if (operstate == dev->operstate)
      53                 :            :                 return;
      54                 :            : 
      55                 :         21 :         write_lock_bh(&dev_base_lock);
      56                 :            : 
      57         [ -  + ]:         21 :         switch(dev->link_mode) {
      58                 :          0 :         case IF_LINK_MODE_DORMANT:
      59         [ #  # ]:          0 :                 if (operstate == IF_OPER_UP)
      60                 :          0 :                         operstate = IF_OPER_DORMANT;
      61                 :            :                 break;
      62                 :            : 
      63                 :            :         case IF_LINK_MODE_DEFAULT:
      64                 :            :         default:
      65                 :            :                 break;
      66                 :            :         }
      67                 :            : 
      68                 :         21 :         dev->operstate = operstate;
      69                 :            : 
      70                 :         21 :         write_unlock_bh(&dev_base_lock);
      71                 :            : }
      72                 :            : 
      73                 :            : 
      74                 :         63 : void linkwatch_init_dev(struct net_device *dev)
      75                 :            : {
      76                 :            :         /* Handle pre-registration link state changes */
      77   [ +  -  -  + ]:        126 :         if (!netif_carrier_ok(dev) || netif_dormant(dev))
      78                 :          0 :                 rfc2863_policy(dev);
      79                 :         63 : }
      80                 :            : 
      81                 :            : 
      82                 :         21 : static bool linkwatch_urgent_event(struct net_device *dev)
      83                 :            : {
      84         [ +  - ]:         21 :         if (!netif_running(dev))
      85                 :            :                 return false;
      86                 :            : 
      87         [ +  - ]:         21 :         if (dev->ifindex != dev_get_iflink(dev))
      88                 :            :                 return true;
      89                 :            : 
      90   [ +  -  +  -  :         63 :         if (netif_is_lag_port(dev) || netif_is_lag_master(dev))
                   +  - ]
      91                 :            :                 return true;
      92                 :            : 
      93   [ -  +  -  - ]:         21 :         return netif_carrier_ok(dev) && qdisc_tx_changing(dev);
      94                 :            : }
      95                 :            : 
      96                 :            : 
      97                 :         21 : static void linkwatch_add_event(struct net_device *dev)
      98                 :            : {
      99                 :         21 :         unsigned long flags;
     100                 :            : 
     101                 :         21 :         spin_lock_irqsave(&lweventlist_lock, flags);
     102         [ +  - ]:         21 :         if (list_empty(&dev->link_watch_list)) {
     103                 :         21 :                 list_add_tail(&dev->link_watch_list, &lweventlist);
     104                 :         21 :                 dev_hold(dev);
     105                 :            :         }
     106                 :         21 :         spin_unlock_irqrestore(&lweventlist_lock, flags);
     107                 :         21 : }
     108                 :            : 
     109                 :            : 
     110                 :         21 : static void linkwatch_schedule_work(int urgent)
     111                 :            : {
     112                 :         21 :         unsigned long delay = linkwatch_nextevent - jiffies;
     113                 :            : 
     114         [ +  - ]:         21 :         if (test_bit(LW_URGENT, &linkwatch_flags))
     115                 :            :                 return;
     116                 :            : 
     117                 :            :         /* Minimise down-time: drop delay for up event. */
     118         [ -  + ]:         21 :         if (urgent) {
     119         [ #  # ]:          0 :                 if (test_and_set_bit(LW_URGENT, &linkwatch_flags))
     120                 :            :                         return;
     121                 :            :                 delay = 0;
     122                 :            :         }
     123                 :            : 
     124                 :            :         /* If we wrap around we'll delay it by at most HZ. */
     125         [ +  - ]:         21 :         if (delay > HZ)
     126                 :         21 :                 delay = 0;
     127                 :            : 
     128                 :            :         /*
     129                 :            :          * If urgent, schedule immediate execution; otherwise, don't
     130                 :            :          * override the existing timer.
     131                 :            :          */
     132         [ -  + ]:         21 :         if (test_bit(LW_URGENT, &linkwatch_flags))
     133                 :          0 :                 mod_delayed_work(system_wq, &linkwatch_work, 0);
     134                 :            :         else
     135                 :         21 :                 schedule_delayed_work(&linkwatch_work, delay);
     136                 :            : }
     137                 :            : 
     138                 :            : 
     139                 :         21 : static void linkwatch_do_dev(struct net_device *dev)
     140                 :            : {
     141                 :            :         /*
     142                 :            :          * Make sure the above read is complete since it can be
     143                 :            :          * rewritten as soon as we clear the bit below.
     144                 :            :          */
     145                 :         21 :         smp_mb__before_atomic();
     146                 :            : 
     147                 :            :         /* We are about to handle this device,
     148                 :            :          * so new events can be accepted
     149                 :            :          */
     150                 :         21 :         clear_bit(__LINK_STATE_LINKWATCH_PENDING, &dev->state);
     151                 :            : 
     152                 :         21 :         rfc2863_policy(dev);
     153   [ +  -  +  - ]:         42 :         if (dev->flags & IFF_UP && netif_device_present(dev)) {
     154         [ -  + ]:         21 :                 if (netif_carrier_ok(dev))
     155                 :          0 :                         dev_activate(dev);
     156                 :            :                 else
     157                 :         21 :                         dev_deactivate(dev);
     158                 :            : 
     159                 :         21 :                 netdev_state_change(dev);
     160                 :            :         }
     161                 :         21 :         dev_put(dev);
     162                 :         21 : }
     163                 :            : 
     164                 :         21 : static void __linkwatch_run_queue(int urgent_only)
     165                 :            : {
     166                 :            : #define MAX_DO_DEV_PER_LOOP     100
     167                 :            : 
     168                 :         21 :         int do_dev = MAX_DO_DEV_PER_LOOP;
     169                 :         21 :         struct net_device *dev;
     170                 :         21 :         LIST_HEAD(wrk);
     171                 :            : 
     172                 :            :         /* Give urgent case more budget */
     173         [ -  + ]:         21 :         if (urgent_only)
     174                 :          0 :                 do_dev += MAX_DO_DEV_PER_LOOP;
     175                 :            : 
     176                 :            :         /*
     177                 :            :          * Limit the number of linkwatch events to one
     178                 :            :          * per second so that a runaway driver does not
     179                 :            :          * cause a storm of messages on the netlink
     180                 :            :          * socket.  This limit does not apply to up events
     181                 :            :          * while the device qdisc is down.
     182                 :            :          */
     183         [ +  - ]:         21 :         if (!urgent_only)
     184                 :         21 :                 linkwatch_nextevent = jiffies + HZ;
     185                 :            :         /* Limit wrap-around effect on delay. */
     186         [ #  # ]:          0 :         else if (time_after(linkwatch_nextevent, jiffies + HZ))
     187                 :          0 :                 linkwatch_nextevent = jiffies;
     188                 :            : 
     189                 :         21 :         clear_bit(LW_URGENT, &linkwatch_flags);
     190                 :            : 
     191                 :         21 :         spin_lock_irq(&lweventlist_lock);
     192         [ +  - ]:         21 :         list_splice_init(&lweventlist, &wrk);
     193                 :            : 
     194   [ +  +  +  - ]:         42 :         while (!list_empty(&wrk) && do_dev > 0) {
     195                 :            : 
     196                 :         21 :                 dev = list_first_entry(&wrk, struct net_device, link_watch_list);
     197         [ -  + ]:         21 :                 list_del_init(&dev->link_watch_list);
     198                 :            : 
     199   [ -  +  -  - ]:         21 :                 if (urgent_only && !linkwatch_urgent_event(dev)) {
     200                 :          0 :                         list_add_tail(&dev->link_watch_list, &lweventlist);
     201                 :          0 :                         continue;
     202                 :            :                 }
     203                 :         21 :                 spin_unlock_irq(&lweventlist_lock);
     204                 :         21 :                 linkwatch_do_dev(dev);
     205                 :         21 :                 do_dev--;
     206                 :         21 :                 spin_lock_irq(&lweventlist_lock);
     207                 :            :         }
     208                 :            : 
     209                 :            :         /* Add the remaining work back to lweventlist */
     210         [ -  + ]:         21 :         list_splice_init(&wrk, &lweventlist);
     211                 :            : 
     212         [ -  + ]:         21 :         if (!list_empty(&lweventlist))
     213                 :          0 :                 linkwatch_schedule_work(0);
     214                 :         21 :         spin_unlock_irq(&lweventlist_lock);
     215                 :         21 : }
     216                 :            : 
     217                 :          0 : void linkwatch_forget_dev(struct net_device *dev)
     218                 :            : {
     219                 :          0 :         unsigned long flags;
     220                 :          0 :         int clean = 0;
     221                 :            : 
     222                 :          0 :         spin_lock_irqsave(&lweventlist_lock, flags);
     223         [ #  # ]:          0 :         if (!list_empty(&dev->link_watch_list)) {
     224                 :          0 :                 list_del_init(&dev->link_watch_list);
     225                 :          0 :                 clean = 1;
     226                 :            :         }
     227                 :          0 :         spin_unlock_irqrestore(&lweventlist_lock, flags);
     228         [ #  # ]:          0 :         if (clean)
     229                 :          0 :                 linkwatch_do_dev(dev);
     230                 :          0 : }
     231                 :            : 
     232                 :            : 
     233                 :            : /* Must be called with the rtnl semaphore held */
     234                 :          0 : void linkwatch_run_queue(void)
     235                 :            : {
     236                 :          0 :         __linkwatch_run_queue(0);
     237                 :          0 : }
     238                 :            : 
     239                 :            : 
     240                 :         21 : static void linkwatch_event(struct work_struct *dummy)
     241                 :            : {
     242                 :         21 :         rtnl_lock();
     243         [ +  - ]:         42 :         __linkwatch_run_queue(time_after(linkwatch_nextevent, jiffies));
     244                 :         21 :         rtnl_unlock();
     245                 :         21 : }
     246                 :            : 
     247                 :            : 
     248                 :         21 : void linkwatch_fire_event(struct net_device *dev)
     249                 :            : {
     250                 :         21 :         bool urgent = linkwatch_urgent_event(dev);
     251                 :            : 
     252         [ +  - ]:         21 :         if (!test_and_set_bit(__LINK_STATE_LINKWATCH_PENDING, &dev->state)) {
     253                 :         21 :                 linkwatch_add_event(dev);
     254         [ #  # ]:          0 :         } else if (!urgent)
     255                 :            :                 return;
     256                 :            : 
     257                 :         21 :         linkwatch_schedule_work(urgent);
     258                 :            : }
     259                 :            : EXPORT_SYMBOL(linkwatch_fire_event);