lkml.org 
[lkml]   [2022]   [Jul]   [5]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 5.15 07/98] net: phy: Dont trigger state machine while in suspend
    Date
    From: Lukas Wunner <lukas@wunner.de>

    commit 1758bde2e4aa5ff188d53e7d9d388bbb7e12eebb upstream.

    Upon system sleep, mdio_bus_phy_suspend() stops the phy_state_machine(),
    but subsequent interrupts may retrigger it:

    They may have been left enabled to facilitate wakeup and are not
    quiesced until the ->suspend_noirq() phase. Unwanted interrupts may
    hence occur between mdio_bus_phy_suspend() and dpm_suspend_noirq(),
    as well as between dpm_resume_noirq() and mdio_bus_phy_resume().

    Retriggering the phy_state_machine() through an interrupt is not only
    undesirable for the reason given in mdio_bus_phy_suspend() (freezing it
    midway with phydev->lock held), but also because the PHY may be
    inaccessible after it's suspended: Accesses to USB-attached PHYs are
    blocked once usb_suspend_both() clears the can_submit flag and PHYs on
    PCI network cards may become inaccessible upon suspend as well.

    Amend phy_interrupt() to avoid triggering the state machine if the PHY
    is suspended. Signal wakeup instead if the attached net_device or its
    parent has been configured as a wakeup source. (Those conditions are
    identical to mdio_bus_phy_may_suspend().) Postpone handling of the
    interrupt until the PHY has resumed.

    Before stopping the phy_state_machine() in mdio_bus_phy_suspend(),
    wait for a concurrent phy_interrupt() to run to completion. That is
    necessary because phy_interrupt() may have checked the PHY's suspend
    status before the system sleep transition commenced and it may thus
    retrigger the state machine after it was stopped.

    Likewise, after re-enabling interrupt handling in mdio_bus_phy_resume(),
    wait for a concurrent phy_interrupt() to complete to ensure that
    interrupts which it postponed are properly rerun.

    The issue was exposed by commit 1ce8b37241ed ("usbnet: smsc95xx: Forward
    PHY interrupts to PHY driver to avoid polling"), but has existed since
    forever.

    Fixes: 541cd3ee00a4 ("phylib: Fix deadlock on resume")
    Link: https://lore.kernel.org/netdev/a5315a8a-32c2-962f-f696-de9a26d30091@samsung.com/
    Reported-by: Marek Szyprowski <m.szyprowski@samsung.com>
    Tested-by: Marek Szyprowski <m.szyprowski@samsung.com>
    Signed-off-by: Lukas Wunner <lukas@wunner.de>
    Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
    Cc: stable@vger.kernel.org # v2.6.33+
    Reviewed-by: Andrew Lunn <andrew@lunn.ch>
    Link: https://lore.kernel.org/r/b7f386d04e9b5b0e2738f0125743e30676f309ef.1656410895.git.lukas@wunner.de
    Signed-off-by: Jakub Kicinski <kuba@kernel.org>
    Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
    ---
    drivers/net/phy/phy.c | 23 +++++++++++++++++++++++
    drivers/net/phy/phy_device.c | 23 +++++++++++++++++++++++
    include/linux/phy.h | 6 ++++++
    3 files changed, 52 insertions(+)

    --- a/drivers/net/phy/phy.c
    +++ b/drivers/net/phy/phy.c
    @@ -31,6 +31,7 @@
    #include <linux/io.h>
    #include <linux/uaccess.h>
    #include <linux/atomic.h>
    +#include <linux/suspend.h>
    #include <net/netlink.h>
    #include <net/genetlink.h>
    #include <net/sock.h>
    @@ -972,6 +973,28 @@ static irqreturn_t phy_interrupt(int irq
    struct phy_driver *drv = phydev->drv;
    irqreturn_t ret;

    + /* Wakeup interrupts may occur during a system sleep transition.
    + * Postpone handling until the PHY has resumed.
    + */
    + if (IS_ENABLED(CONFIG_PM_SLEEP) && phydev->irq_suspended) {
    + struct net_device *netdev = phydev->attached_dev;
    +
    + if (netdev) {
    + struct device *parent = netdev->dev.parent;
    +
    + if (netdev->wol_enabled)
    + pm_system_wakeup();
    + else if (device_may_wakeup(&netdev->dev))
    + pm_wakeup_dev_event(&netdev->dev, 0, true);
    + else if (parent && device_may_wakeup(parent))
    + pm_wakeup_dev_event(parent, 0, true);
    + }
    +
    + phydev->irq_rerun = 1;
    + disable_irq_nosync(irq);
    + return IRQ_HANDLED;
    + }
    +
    mutex_lock(&phydev->lock);
    ret = drv->handle_interrupt(phydev);
    mutex_unlock(&phydev->lock);
    --- a/drivers/net/phy/phy_device.c
    +++ b/drivers/net/phy/phy_device.c
    @@ -277,6 +277,15 @@ static __maybe_unused int mdio_bus_phy_s
    if (phydev->mac_managed_pm)
    return 0;

    + /* Wakeup interrupts may occur during the system sleep transition when
    + * the PHY is inaccessible. Set flag to postpone handling until the PHY
    + * has resumed. Wait for concurrent interrupt handler to complete.
    + */
    + if (phy_interrupt_is_valid(phydev)) {
    + phydev->irq_suspended = 1;
    + synchronize_irq(phydev->irq);
    + }
    +
    /* We must stop the state machine manually, otherwise it stops out of
    * control, possibly with the phydev->lock held. Upon resume, netdev
    * may call phy routines that try to grab the same lock, and that may
    @@ -314,6 +323,20 @@ static __maybe_unused int mdio_bus_phy_r
    if (ret < 0)
    return ret;
    no_resume:
    + if (phy_interrupt_is_valid(phydev)) {
    + phydev->irq_suspended = 0;
    + synchronize_irq(phydev->irq);
    +
    + /* Rerun interrupts which were postponed by phy_interrupt()
    + * because they occurred during the system sleep transition.
    + */
    + if (phydev->irq_rerun) {
    + phydev->irq_rerun = 0;
    + enable_irq(phydev->irq);
    + irq_wake_thread(phydev->irq, phydev);
    + }
    + }
    +
    if (phydev->attached_dev && phydev->adjust_link)
    phy_start_machine(phydev);

    --- a/include/linux/phy.h
    +++ b/include/linux/phy.h
    @@ -536,6 +536,10 @@ struct macsec_ops;
    * @mdix: Current crossover
    * @mdix_ctrl: User setting of crossover
    * @interrupts: Flag interrupts have been enabled
    + * @irq_suspended: Flag indicating PHY is suspended and therefore interrupt
    + * handling shall be postponed until PHY has resumed
    + * @irq_rerun: Flag indicating interrupts occurred while PHY was suspended,
    + * requiring a rerun of the interrupt handler after resume
    * @interface: enum phy_interface_t value
    * @skb: Netlink message for cable diagnostics
    * @nest: Netlink nest used for cable diagnostics
    @@ -590,6 +594,8 @@ struct phy_device {

    /* Interrupts are enabled */
    unsigned interrupts:1;
    + unsigned irq_suspended:1;
    + unsigned irq_rerun:1;

    enum phy_state state;


    \
     
     \ /
      Last update: 2022-07-05 14:25    [W:7.482 / U:0.048 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site