netpoll: protect napi_poll and poll_controller during dev_[open|close]

Ivan Vercera was recently backporting commit
9c13cb8bb477a83b9a3c9e5a5478a4e21294a760 to a RHEL kernel, and I noticed that,
while this patch protects the tg3 driver from having its ndo_poll_controller
routine called during device initalization, it does nothing for the driver
during shutdown. I.e. it would be entirely possible to have the
ndo_poll_controller method (or subsequently the ndo_poll) routine called for a
driver in the netpoll path on CPU A while in parallel on CPU B, the ndo_close or
ndo_open routine could be called.  Given that the two latter routines tend to
initizlize and free many data structures that the former two rely on, the result
can easily be data corruption or various other crashes.  Furthermore, it seems
that this is potentially a problem with all net drivers that support netpoll,
and so this should ideally be fixed in a common path.

As Ben H Pointed out to me, we can't preform dev_open/dev_close in atomic
context, so I've come up with this solution.  We can use a mutex to sleep in
open/close paths and just do a mutex_trylock in the napi poll path and abandon
the poll attempt if we're locked, as we'll just retry the poll on the next send
anyway.

I've tested this here by flooding netconsole with messages on a system whos nic
driver I modfied to periodically return NETDEV_TX_BUSY, so that the netpoll tx
workqueue would be forced to send frames and poll the device.  While this was
going on I rapidly ifdown/up'ed the interface and watched for any problems.
I've not found any.

Signed-off-by: Neil Horman <nhorman@tuxdriver.com>
CC: Ivan Vecera <ivecera@redhat.com>
CC: "David S. Miller" <davem@davemloft.net>
CC: Ben Hutchings <bhutchings@solarflare.com>
CC: Francois Romieu <romieu@fr.zoreil.com>
CC: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 26 insertions, 1 deletions

diff --git a/net/core/dev.c b/net/core/dev.c
index e04bfdc9e3e4..2b275a7b8677 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1266,6 +1266,14 @@ static int __dev_open(struct net_device *dev)
         if (!netif_device_present(dev))
                 return -ENODEV;
 
+        /* Block netpoll from trying to do any rx path servicing.
+         * If we don't do this there is a chance ndo_poll_controller
+         * or ndo_poll may be running while we open the device
+         */
+        ret = netpoll_rx_disable(dev);
+        if (ret)
+                return ret;
+
         ret = call_netdevice_notifiers(NETDEV_PRE_UP, dev);
         ret = notifier_to_errno(ret);
         if (ret)
@@ -1279,6 +1287,8 @@ static int __dev_open(struct net_device *dev)
         if (!ret && ops->ndo_open)
                 ret = ops->ndo_open(dev);
 
+        netpoll_rx_enable(dev);
+
         if (ret)
                 clear_bit(__LINK_STATE_START, &dev->state);
         else {
@@ -1370,9 +1380,16 @@ static int __dev_close(struct net_device *dev)
         int retval;
         LIST_HEAD(single);
 
+        /* Temporarily disable netpoll until the interface is down */
+        retval = netpoll_rx_disable(dev);
+        if (retval)
+                return retval;
+
         list_add(&dev->unreg_list, &single);
         retval = __dev_close_many(&single);
         list_del(&single);
+
+        netpoll_rx_enable(dev);
         return retval;
 }
 
@@ -1408,14 +1425,22 @@ static int dev_close_many(struct list_head *head)
  */
 int dev_close(struct net_device *dev)
 {
+        int ret = 0;
         if (dev->flags & IFF_UP) {
                 LIST_HEAD(single);
 
+                /* Block netpoll rx while the interface is going down */
+                ret = netpoll_rx_disable(dev);
+                if (ret)
+                        return ret;
+
                 list_add(&dev->unreg_list, &single);
                 dev_close_many(&single);
                 list_del(&single);
+
+                netpoll_rx_enable(dev);
         }
-        return 0;
+        return ret;
 }
 EXPORT_SYMBOL(dev_close);