2005-11-04 01:52:49 +01:00
|
|
|
/*
|
|
|
|
* PCI Error Recovery Driver for RPA-compliant PPC64 platform.
|
2007-05-23 19:28:01 +02:00
|
|
|
* Copyright IBM Corp. 2004 2005
|
|
|
|
* Copyright Linas Vepstas <linas@linas.org> 2004, 2005
|
2005-11-04 01:52:49 +01:00
|
|
|
*
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or (at
|
|
|
|
* your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
|
|
|
|
* NON INFRINGEMENT. See the GNU General Public License for more
|
|
|
|
* details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*
|
2007-05-23 19:28:01 +02:00
|
|
|
* Send comments and feedback to Linas Vepstas <linas@austin.ibm.com>
|
2005-11-04 01:52:49 +01:00
|
|
|
*/
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/interrupt.h>
|
2006-04-19 06:05:21 +02:00
|
|
|
#include <linux/irq.h>
|
2012-09-17 06:34:27 +02:00
|
|
|
#include <linux/module.h>
|
2005-11-04 01:52:49 +01:00
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <asm/eeh.h>
|
|
|
|
#include <asm/eeh_event.h>
|
|
|
|
#include <asm/ppc-pci.h>
|
|
|
|
#include <asm/pci-bridge.h>
|
|
|
|
#include <asm/prom.h>
|
|
|
|
#include <asm/rtas.h>
|
|
|
|
|
2016-03-04 00:53:11 +01:00
|
|
|
struct eeh_rmv_data {
|
|
|
|
struct list_head edev_list;
|
|
|
|
int removed;
|
|
|
|
};
|
|
|
|
|
2012-02-27 21:04:02 +01:00
|
|
|
/**
|
|
|
|
* eeh_pcid_name - Retrieve name of PCI device driver
|
|
|
|
* @pdev: PCI device
|
|
|
|
*
|
|
|
|
* This routine is used to retrieve the name of PCI device driver
|
|
|
|
* if that's valid.
|
|
|
|
*/
|
2012-02-27 21:04:08 +01:00
|
|
|
static inline const char *eeh_pcid_name(struct pci_dev *pdev)
|
2005-11-04 01:52:49 +01:00
|
|
|
{
|
2006-02-27 15:52:59 +01:00
|
|
|
if (pdev && pdev->dev.driver)
|
2005-11-04 01:52:49 +01:00
|
|
|
return pdev->dev.driver->name;
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2012-09-17 06:34:27 +02:00
|
|
|
/**
|
|
|
|
* eeh_pcid_get - Get the PCI device driver
|
|
|
|
* @pdev: PCI device
|
|
|
|
*
|
|
|
|
* The function is used to retrieve the PCI device driver for
|
|
|
|
* the indicated PCI device. Besides, we will increase the reference
|
|
|
|
* of the PCI device driver to prevent that being unloaded on
|
|
|
|
* the fly. Otherwise, kernel crash would be seen.
|
|
|
|
*/
|
|
|
|
static inline struct pci_driver *eeh_pcid_get(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
if (!pdev || !pdev->driver)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!try_module_get(pdev->driver->driver.owner))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return pdev->driver;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* eeh_pcid_put - Dereference on the PCI device driver
|
|
|
|
* @pdev: PCI device
|
|
|
|
*
|
|
|
|
* The function is called to do dereference on the PCI device
|
|
|
|
* driver of the indicated PCI device.
|
|
|
|
*/
|
|
|
|
static inline void eeh_pcid_put(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
if (!pdev || !pdev->driver)
|
|
|
|
return;
|
|
|
|
|
|
|
|
module_put(pdev->driver->driver.owner);
|
|
|
|
}
|
|
|
|
|
2009-02-10 12:12:21 +01:00
|
|
|
/**
|
2012-02-27 21:04:02 +01:00
|
|
|
* eeh_disable_irq - Disable interrupt for the recovering device
|
|
|
|
* @dev: PCI device
|
|
|
|
*
|
|
|
|
* This routine must be called when reporting temporary or permanent
|
|
|
|
* error to the particular PCI device to disable interrupt of that
|
|
|
|
* device. If the device has enabled MSI or MSI-X interrupt, we needn't
|
|
|
|
* do real work because EEH should freeze DMA transfers for those PCI
|
|
|
|
* devices encountering EEH errors, which includes MSI or MSI-X.
|
2009-02-10 12:12:21 +01:00
|
|
|
*/
|
|
|
|
static void eeh_disable_irq(struct pci_dev *dev)
|
|
|
|
{
|
2012-02-27 21:04:08 +01:00
|
|
|
struct eeh_dev *edev = pci_dev_to_eeh_dev(dev);
|
2009-02-10 12:12:21 +01:00
|
|
|
|
|
|
|
/* Don't disable MSI and MSI-X interrupts. They are
|
|
|
|
* effectively disabled by the DMA Stopped state
|
|
|
|
* when an EEH error occurs.
|
2012-02-27 21:04:02 +01:00
|
|
|
*/
|
2009-02-10 12:12:21 +01:00
|
|
|
if (dev->msi_enabled || dev->msix_enabled)
|
|
|
|
return;
|
|
|
|
|
2009-10-13 21:44:47 +02:00
|
|
|
if (!irq_has_action(dev->irq))
|
2009-02-10 12:12:21 +01:00
|
|
|
return;
|
|
|
|
|
2012-09-08 00:44:20 +02:00
|
|
|
edev->mode |= EEH_DEV_IRQ_DISABLED;
|
2009-02-10 12:12:21 +01:00
|
|
|
disable_irq_nosync(dev->irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-02-27 21:04:02 +01:00
|
|
|
* eeh_enable_irq - Enable interrupt for the recovering device
|
|
|
|
* @dev: PCI device
|
|
|
|
*
|
|
|
|
* This routine must be called to enable interrupt while failed
|
|
|
|
* device could be resumed.
|
2009-02-10 12:12:21 +01:00
|
|
|
*/
|
|
|
|
static void eeh_enable_irq(struct pci_dev *dev)
|
|
|
|
{
|
2012-02-27 21:04:08 +01:00
|
|
|
struct eeh_dev *edev = pci_dev_to_eeh_dev(dev);
|
2009-02-10 12:12:21 +01:00
|
|
|
|
2012-09-08 00:44:20 +02:00
|
|
|
if ((edev->mode) & EEH_DEV_IRQ_DISABLED) {
|
|
|
|
edev->mode &= ~EEH_DEV_IRQ_DISABLED;
|
2014-02-23 22:40:09 +01:00
|
|
|
/*
|
|
|
|
* FIXME !!!!!
|
|
|
|
*
|
|
|
|
* This is just ass backwards. This maze has
|
|
|
|
* unbalanced irq_enable/disable calls. So instead of
|
|
|
|
* finding the root cause it works around the warning
|
|
|
|
* in the irq_enable code by conditionally calling
|
|
|
|
* into it.
|
|
|
|
*
|
|
|
|
* That's just wrong.The warning in the core code is
|
2016-06-01 08:34:37 +02:00
|
|
|
* there to tell people to fix their asymmetries in
|
2014-02-23 22:40:09 +01:00
|
|
|
* their own code, not by abusing the core information
|
|
|
|
* to avoid it.
|
|
|
|
*
|
|
|
|
* I so wish that the assymetry would be the other way
|
|
|
|
* round and a few more irq_disable calls render that
|
|
|
|
* shit unusable forever.
|
|
|
|
*
|
|
|
|
* tglx
|
|
|
|
*/
|
2014-03-05 00:06:11 +01:00
|
|
|
if (irqd_irq_disabled(irq_get_irq_data(dev->irq)))
|
2013-07-24 04:25:00 +02:00
|
|
|
enable_irq(dev->irq);
|
2014-03-05 00:06:11 +01:00
|
|
|
}
|
2009-02-10 12:12:21 +01:00
|
|
|
}
|
|
|
|
|
powerpc/eeh: No hotplug on permanently removed dev
The issue was detected in a bit complicated test case where
we have multiple hierarchical PEs shown as following figure:
+-----------------+
| PE#3 p2p#0 |
| p2p#1 |
+-----------------+
|
+-----------------+
| PE#4 pdev#0 |
| pdev#1 |
+-----------------+
PE#4 (have 2 PCI devices) is the child of PE#3, which has 2 p2p
bridges. We accidentally had less-known scenario: PE#4 was removed
permanently from the system because of permanent failure (e.g.
exceeding the max allowd failure times in last hour), then we detects
EEH errors on PE#3 and tried to recover it. However, eeh_dev instances
for pdev#0/1 were not detached from PE#4, which was still connected to
PE#3. All of that was because of the fact that we rely on count-based
pcibios_release_device(), which isn't reliable enough. When doing
recovery for PE#3, we still apply hotplug on PE#4 and pdev#0/1, which
are not valid any more. Eventually, we run into kernel crash.
The patch fixes above issue from two aspects. For unplug, we simply
skip those permanently removed PE, whose state is (EEH_PE_STATE_ISOLATED
&& !EEH_PE_STATE_RECOVERING) and its frozen count should be greater
than EEH_MAX_ALLOWED_FREEZES. For plug, we marked all permanently
removed EEH devices with EEH_DEV_REMOVED and return 0xFF's on read
its PCI config so that PCI core will omit them.
Signed-off-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-04-24 10:00:19 +02:00
|
|
|
static bool eeh_dev_removed(struct eeh_dev *edev)
|
|
|
|
{
|
|
|
|
/* EEH device removed ? */
|
|
|
|
if (!edev || (edev->mode & EEH_DEV_REMOVED))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-09-30 04:39:07 +02:00
|
|
|
static void *eeh_dev_save_state(void *data, void *userdata)
|
|
|
|
{
|
|
|
|
struct eeh_dev *edev = data;
|
|
|
|
struct pci_dev *pdev;
|
|
|
|
|
|
|
|
if (!edev)
|
|
|
|
return NULL;
|
|
|
|
|
2016-04-27 03:14:51 +02:00
|
|
|
/*
|
|
|
|
* We cannot access the config space on some adapters.
|
|
|
|
* Otherwise, it will cause fenced PHB. We don't save
|
|
|
|
* the content in their config space and will restore
|
|
|
|
* from the initial config space saved when the EEH
|
|
|
|
* device is created.
|
|
|
|
*/
|
|
|
|
if (edev->pe && (edev->pe->state & EEH_PE_CFG_RESTRICTED))
|
|
|
|
return NULL;
|
|
|
|
|
2014-09-30 04:39:07 +02:00
|
|
|
pdev = eeh_dev_to_pci_dev(edev);
|
|
|
|
if (!pdev)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
pci_save_state(pdev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-09-16 01:56:35 +02:00
|
|
|
/**
|
2012-02-27 21:04:02 +01:00
|
|
|
* eeh_report_error - Report pci error to each device driver
|
2012-09-08 00:44:19 +02:00
|
|
|
* @data: eeh device
|
2012-02-27 21:04:02 +01:00
|
|
|
* @userdata: return value
|
2013-06-20 07:20:51 +02:00
|
|
|
*
|
|
|
|
* Report an EEH error to each device driver, collect up and
|
|
|
|
* merge the device driver responses. Cumulative response
|
2006-09-16 01:56:35 +02:00
|
|
|
* passed back in "userdata".
|
2005-11-04 01:52:49 +01:00
|
|
|
*/
|
2012-09-08 00:44:19 +02:00
|
|
|
static void *eeh_report_error(void *data, void *userdata)
|
2005-11-04 01:52:49 +01:00
|
|
|
{
|
2012-09-08 00:44:19 +02:00
|
|
|
struct eeh_dev *edev = (struct eeh_dev *)data;
|
|
|
|
struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
|
2005-11-29 07:17:02 +01:00
|
|
|
enum pci_ers_result rc, *res = userdata;
|
2012-09-17 06:34:27 +02:00
|
|
|
struct pci_driver *driver;
|
2005-11-04 01:52:49 +01:00
|
|
|
|
2016-03-04 00:53:12 +01:00
|
|
|
if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
|
powerpc/eeh: No hotplug on permanently removed dev
The issue was detected in a bit complicated test case where
we have multiple hierarchical PEs shown as following figure:
+-----------------+
| PE#3 p2p#0 |
| p2p#1 |
+-----------------+
|
+-----------------+
| PE#4 pdev#0 |
| pdev#1 |
+-----------------+
PE#4 (have 2 PCI devices) is the child of PE#3, which has 2 p2p
bridges. We accidentally had less-known scenario: PE#4 was removed
permanently from the system because of permanent failure (e.g.
exceeding the max allowd failure times in last hour), then we detects
EEH errors on PE#3 and tried to recover it. However, eeh_dev instances
for pdev#0/1 were not detached from PE#4, which was still connected to
PE#3. All of that was because of the fact that we rely on count-based
pcibios_release_device(), which isn't reliable enough. When doing
recovery for PE#3, we still apply hotplug on PE#4 and pdev#0/1, which
are not valid any more. Eventually, we run into kernel crash.
The patch fixes above issue from two aspects. For unplug, we simply
skip those permanently removed PE, whose state is (EEH_PE_STATE_ISOLATED
&& !EEH_PE_STATE_RECOVERING) and its frozen count should be greater
than EEH_MAX_ALLOWED_FREEZES. For plug, we marked all permanently
removed EEH devices with EEH_DEV_REMOVED and return 0xFF's on read
its PCI config so that PCI core will omit them.
Signed-off-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-04-24 10:00:19 +02:00
|
|
|
return NULL;
|
2005-11-04 01:52:49 +01:00
|
|
|
dev->error_state = pci_channel_io_frozen;
|
|
|
|
|
2012-09-17 06:34:27 +02:00
|
|
|
driver = eeh_pcid_get(dev);
|
|
|
|
if (!driver) return NULL;
|
2005-11-04 01:52:49 +01:00
|
|
|
|
2009-02-10 12:12:21 +01:00
|
|
|
eeh_disable_irq(dev);
|
|
|
|
|
2006-09-16 01:58:59 +02:00
|
|
|
if (!driver->err_handler ||
|
2012-09-17 06:34:27 +02:00
|
|
|
!driver->err_handler->error_detected) {
|
|
|
|
eeh_pcid_put(dev);
|
2012-09-08 00:44:19 +02:00
|
|
|
return NULL;
|
2012-09-17 06:34:27 +02:00
|
|
|
}
|
2005-11-04 01:52:49 +01:00
|
|
|
|
2012-02-27 21:04:02 +01:00
|
|
|
rc = driver->err_handler->error_detected(dev, pci_channel_io_frozen);
|
2007-11-02 21:27:50 +01:00
|
|
|
|
|
|
|
/* A driver that needs a reset trumps all others */
|
|
|
|
if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
|
2005-11-29 07:17:02 +01:00
|
|
|
if (*res == PCI_ERS_RESULT_NONE) *res = rc;
|
2009-06-16 07:34:38 +02:00
|
|
|
|
2016-03-04 00:53:11 +01:00
|
|
|
edev->in_error = true;
|
2012-09-17 06:34:27 +02:00
|
|
|
eeh_pcid_put(dev);
|
2012-09-08 00:44:19 +02:00
|
|
|
return NULL;
|
2006-09-16 01:58:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-02-27 21:04:02 +01:00
|
|
|
* eeh_report_mmio_enabled - Tell drivers that MMIO has been enabled
|
2012-09-08 00:44:19 +02:00
|
|
|
* @data: eeh device
|
2012-02-27 21:04:02 +01:00
|
|
|
* @userdata: return value
|
2006-09-16 01:58:59 +02:00
|
|
|
*
|
2007-11-02 21:25:55 +01:00
|
|
|
* Tells each device driver that IO ports, MMIO and config space I/O
|
|
|
|
* are now enabled. Collects up and merges the device driver responses.
|
|
|
|
* Cumulative response passed back in "userdata".
|
2006-09-16 01:58:59 +02:00
|
|
|
*/
|
2012-09-08 00:44:19 +02:00
|
|
|
static void *eeh_report_mmio_enabled(void *data, void *userdata)
|
2006-09-16 01:58:59 +02:00
|
|
|
{
|
2012-09-08 00:44:19 +02:00
|
|
|
struct eeh_dev *edev = (struct eeh_dev *)data;
|
|
|
|
struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
|
2006-09-16 01:58:59 +02:00
|
|
|
enum pci_ers_result rc, *res = userdata;
|
2012-09-08 00:44:19 +02:00
|
|
|
struct pci_driver *driver;
|
2006-09-16 01:58:59 +02:00
|
|
|
|
2016-03-04 00:53:12 +01:00
|
|
|
if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
|
powerpc/eeh: No hotplug on permanently removed dev
The issue was detected in a bit complicated test case where
we have multiple hierarchical PEs shown as following figure:
+-----------------+
| PE#3 p2p#0 |
| p2p#1 |
+-----------------+
|
+-----------------+
| PE#4 pdev#0 |
| pdev#1 |
+-----------------+
PE#4 (have 2 PCI devices) is the child of PE#3, which has 2 p2p
bridges. We accidentally had less-known scenario: PE#4 was removed
permanently from the system because of permanent failure (e.g.
exceeding the max allowd failure times in last hour), then we detects
EEH errors on PE#3 and tried to recover it. However, eeh_dev instances
for pdev#0/1 were not detached from PE#4, which was still connected to
PE#3. All of that was because of the fact that we rely on count-based
pcibios_release_device(), which isn't reliable enough. When doing
recovery for PE#3, we still apply hotplug on PE#4 and pdev#0/1, which
are not valid any more. Eventually, we run into kernel crash.
The patch fixes above issue from two aspects. For unplug, we simply
skip those permanently removed PE, whose state is (EEH_PE_STATE_ISOLATED
&& !EEH_PE_STATE_RECOVERING) and its frozen count should be greater
than EEH_MAX_ALLOWED_FREEZES. For plug, we marked all permanently
removed EEH devices with EEH_DEV_REMOVED and return 0xFF's on read
its PCI config so that PCI core will omit them.
Signed-off-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-04-24 10:00:19 +02:00
|
|
|
return NULL;
|
|
|
|
|
2012-09-17 06:34:27 +02:00
|
|
|
driver = eeh_pcid_get(dev);
|
|
|
|
if (!driver) return NULL;
|
2012-09-08 00:44:19 +02:00
|
|
|
|
2012-09-17 06:34:27 +02:00
|
|
|
if (!driver->err_handler ||
|
2014-01-12 07:13:45 +01:00
|
|
|
!driver->err_handler->mmio_enabled ||
|
|
|
|
(edev->mode & EEH_DEV_NO_HANDLER)) {
|
2012-09-17 06:34:27 +02:00
|
|
|
eeh_pcid_put(dev);
|
2012-09-08 00:44:19 +02:00
|
|
|
return NULL;
|
2012-09-17 06:34:27 +02:00
|
|
|
}
|
2006-09-16 01:58:59 +02:00
|
|
|
|
2012-02-27 21:04:02 +01:00
|
|
|
rc = driver->err_handler->mmio_enabled(dev);
|
2007-11-02 21:27:50 +01:00
|
|
|
|
|
|
|
/* A driver that needs a reset trumps all others */
|
|
|
|
if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
|
2006-09-16 01:58:59 +02:00
|
|
|
if (*res == PCI_ERS_RESULT_NONE) *res = rc;
|
2009-06-16 07:34:38 +02:00
|
|
|
|
2012-09-17 06:34:27 +02:00
|
|
|
eeh_pcid_put(dev);
|
2012-09-08 00:44:19 +02:00
|
|
|
return NULL;
|
2005-11-04 01:52:49 +01:00
|
|
|
}
|
|
|
|
|
2006-09-16 01:56:35 +02:00
|
|
|
/**
|
2012-02-27 21:04:02 +01:00
|
|
|
* eeh_report_reset - Tell device that slot has been reset
|
2012-09-08 00:44:19 +02:00
|
|
|
* @data: eeh device
|
2012-02-27 21:04:02 +01:00
|
|
|
* @userdata: return value
|
|
|
|
*
|
|
|
|
* This routine must be called while EEH tries to reset particular
|
|
|
|
* PCI device so that the associated PCI device driver could take
|
|
|
|
* some actions, usually to save data the driver needs so that the
|
|
|
|
* driver can work again while the device is recovered.
|
2005-11-04 01:52:49 +01:00
|
|
|
*/
|
2012-09-08 00:44:19 +02:00
|
|
|
static void *eeh_report_reset(void *data, void *userdata)
|
2005-11-04 01:52:49 +01:00
|
|
|
{
|
2012-09-08 00:44:19 +02:00
|
|
|
struct eeh_dev *edev = (struct eeh_dev *)data;
|
|
|
|
struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
|
2006-09-16 01:58:59 +02:00
|
|
|
enum pci_ers_result rc, *res = userdata;
|
2012-09-08 00:44:19 +02:00
|
|
|
struct pci_driver *driver;
|
2005-11-04 01:52:49 +01:00
|
|
|
|
2016-03-04 00:53:12 +01:00
|
|
|
if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
|
powerpc/eeh: No hotplug on permanently removed dev
The issue was detected in a bit complicated test case where
we have multiple hierarchical PEs shown as following figure:
+-----------------+
| PE#3 p2p#0 |
| p2p#1 |
+-----------------+
|
+-----------------+
| PE#4 pdev#0 |
| pdev#1 |
+-----------------+
PE#4 (have 2 PCI devices) is the child of PE#3, which has 2 p2p
bridges. We accidentally had less-known scenario: PE#4 was removed
permanently from the system because of permanent failure (e.g.
exceeding the max allowd failure times in last hour), then we detects
EEH errors on PE#3 and tried to recover it. However, eeh_dev instances
for pdev#0/1 were not detached from PE#4, which was still connected to
PE#3. All of that was because of the fact that we rely on count-based
pcibios_release_device(), which isn't reliable enough. When doing
recovery for PE#3, we still apply hotplug on PE#4 and pdev#0/1, which
are not valid any more. Eventually, we run into kernel crash.
The patch fixes above issue from two aspects. For unplug, we simply
skip those permanently removed PE, whose state is (EEH_PE_STATE_ISOLATED
&& !EEH_PE_STATE_RECOVERING) and its frozen count should be greater
than EEH_MAX_ALLOWED_FREEZES. For plug, we marked all permanently
removed EEH devices with EEH_DEV_REMOVED and return 0xFF's on read
its PCI config so that PCI core will omit them.
Signed-off-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-04-24 10:00:19 +02:00
|
|
|
return NULL;
|
powerpc/pseries: Set error_state to pci_channel_io_normal in eeh_report_reset()
While adding native EEH support to Emulex and Qlogic drivers, it was
discovered that dev->error_state was set to pci_io_channel_normal too
late in the recovery process. These drivers rely on error_state to
determine if they can access the device in their slot_reset callback,
thus error_state needs to be set to pci_io_channel_normal in
eeh_report_reset(). Below is a detailed explanation (courtesy of Richard
Lary) as to why this is necessary.
Background:
PCI MMIO or DMA accesses to a frozen slot generate additional EEH
errors. If the number of additional EEH errors exceeds EEH_MAX_FAILS the
adapter will be shutdown. To avoid triggering excessive EEH errors and
an undesirable adapter shutdown, some drivers use the
pci_channel_offline(dev) wrapper function to return a Boolean value
based on the value of pci_dev->error_state to determine if PCI MMIO or
DMA accesses are safe. If the wrapper returns TRUE, drivers must not
make PCI MMIO or DMA access to their hardware.
The pci_dev structure member error_state reflects one of three values,
1) pci_channel_io_normal, 2) pci_channel_io_frozen, 3)
pci_channel_io_perm_failure. Function pci_channel_offline(dev) returns
TRUE if error_state is pci_channel_io_frozen or pci_channel_io_perm_failure.
The EEH driver sets pci_dev->error_state to pci_channel_io_frozen at the
point where the PCI slot is frozen. Currently, the EEH driver restores
dev->error_state to pci_channel_io_normal in eeh_report_resume() before
calling the driver's resume callback. However, when the EEH driver calls
the driver's slot_reset callback() from eeh_report_reset(), it
incorrectly indicates the error state is still pci_channel_io_frozen.
Waiting until eeh_report_resume() to restore dev->error_state to
pci_channel_io_normal is too late for Emulex and QLogic FC drivers and
any other drivers which are designed to use common code paths in these
two cases: i) those called after the driver's slot_reset callback() and
ii) those called after the PCI slot is frozen but before the driver's
slot_reset callback is called. Case i) all driver paths executed to
reinitialize the hardware after a reset and case ii) all code paths
executed by driver kernel threads that run asynchronous to the main
driver thread, such as interrupt handlers and worker threads to process
driver work queues.
Emulex and QLogic FC drivers are designed with common code paths which
require that pci_channel_offline(dev) reflect the true state of the
hardware. The state transitions that the hardware takes from Normal
Operations to Slot Frozen to Reset to Normal Operations are documented
in the Power Architecture™ Platform Requirements+ (PAPR+) in Table 75.
PE State Control.
PAPR defines the following 3 states:
0 -- Not reset, Not EEH stopped, MMIO load/store allowed, DMA allowed
(Normal Operations)
1 -- Reset, Not EEH stopped, MMIO load/store disabled, DMA disabled
2 -- Not reset, EEH stopped, MMIO load/store disabled, DMA disabled
(Slot Frozen)
An EEH error places the slot in state 2 (Frozen) and the adapter driver
is notified that an EEH error was detected. If the adapter driver
returns PCI_ERS_RESULT_NEED_RESET, the EEH driver calls
eeh_reset_device() to place the slot into state 1 (Reset) and
eeh_reset_device completes by placing the slot into State 0 (Normal
Operations). Upon return from eeh_reset_device(), the EEH driver calls
eeh_report_reset, which then calls the adapter's slot_reset callback. At
the time the adapter's slot_reset callback is called, the true state of
the hardware is Normal Operations and should be accurately reflected by
setting dev->error_state to pci_channel_io_normal.
The current implementation of EEH driver does not do so and requires
this change to correct this deficiency.
Signed-off-by: Mike Mason <mmlnx@us.ibm.com>
Acked-by: Linas Vepstas <linasvepstas@gmail.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2009-04-10 10:57:03 +02:00
|
|
|
dev->error_state = pci_channel_io_normal;
|
|
|
|
|
2012-09-17 06:34:27 +02:00
|
|
|
driver = eeh_pcid_get(dev);
|
|
|
|
if (!driver) return NULL;
|
|
|
|
|
2009-02-10 12:12:21 +01:00
|
|
|
eeh_enable_irq(dev);
|
|
|
|
|
2006-09-16 01:58:59 +02:00
|
|
|
if (!driver->err_handler ||
|
2014-01-12 07:13:45 +01:00
|
|
|
!driver->err_handler->slot_reset ||
|
2016-03-04 00:53:11 +01:00
|
|
|
(edev->mode & EEH_DEV_NO_HANDLER) ||
|
|
|
|
(!edev->in_error)) {
|
2012-09-17 06:34:27 +02:00
|
|
|
eeh_pcid_put(dev);
|
2012-09-08 00:44:19 +02:00
|
|
|
return NULL;
|
2012-09-17 06:34:27 +02:00
|
|
|
}
|
2005-11-04 01:52:49 +01:00
|
|
|
|
2006-09-16 01:58:59 +02:00
|
|
|
rc = driver->err_handler->slot_reset(dev);
|
2007-03-19 20:55:51 +01:00
|
|
|
if ((*res == PCI_ERS_RESULT_NONE) ||
|
|
|
|
(*res == PCI_ERS_RESULT_RECOVERED)) *res = rc;
|
2006-09-16 01:58:59 +02:00
|
|
|
if (*res == PCI_ERS_RESULT_DISCONNECT &&
|
|
|
|
rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
|
2009-06-16 07:34:38 +02:00
|
|
|
|
2012-09-17 06:34:27 +02:00
|
|
|
eeh_pcid_put(dev);
|
2012-09-08 00:44:19 +02:00
|
|
|
return NULL;
|
2005-11-04 01:52:49 +01:00
|
|
|
}
|
|
|
|
|
2014-09-30 04:39:07 +02:00
|
|
|
static void *eeh_dev_restore_state(void *data, void *userdata)
|
|
|
|
{
|
|
|
|
struct eeh_dev *edev = data;
|
|
|
|
struct pci_dev *pdev;
|
|
|
|
|
|
|
|
if (!edev)
|
|
|
|
return NULL;
|
|
|
|
|
2016-04-27 03:14:51 +02:00
|
|
|
/*
|
|
|
|
* The content in the config space isn't saved because
|
|
|
|
* the blocked config space on some adapters. We have
|
|
|
|
* to restore the initial saved config space when the
|
|
|
|
* EEH device is created.
|
|
|
|
*/
|
|
|
|
if (edev->pe && (edev->pe->state & EEH_PE_CFG_RESTRICTED)) {
|
|
|
|
if (list_is_last(&edev->list, &edev->pe->edevs))
|
|
|
|
eeh_pe_restore_bars(edev->pe);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-09-30 04:39:07 +02:00
|
|
|
pdev = eeh_dev_to_pci_dev(edev);
|
|
|
|
if (!pdev)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
pci_restore_state(pdev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-09-16 01:56:35 +02:00
|
|
|
/**
|
2012-02-27 21:04:02 +01:00
|
|
|
* eeh_report_resume - Tell device to resume normal operations
|
2012-09-08 00:44:19 +02:00
|
|
|
* @data: eeh device
|
2012-02-27 21:04:02 +01:00
|
|
|
* @userdata: return value
|
|
|
|
*
|
|
|
|
* This routine must be called to notify the device driver that it
|
|
|
|
* could resume so that the device driver can do some initialization
|
|
|
|
* to make the recovered device work again.
|
2006-09-16 01:56:35 +02:00
|
|
|
*/
|
2012-09-08 00:44:19 +02:00
|
|
|
static void *eeh_report_resume(void *data, void *userdata)
|
2005-11-04 01:52:49 +01:00
|
|
|
{
|
2012-09-08 00:44:19 +02:00
|
|
|
struct eeh_dev *edev = (struct eeh_dev *)data;
|
|
|
|
struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
|
2016-03-04 00:53:11 +01:00
|
|
|
bool was_in_error;
|
2012-09-08 00:44:19 +02:00
|
|
|
struct pci_driver *driver;
|
|
|
|
|
2016-03-04 00:53:12 +01:00
|
|
|
if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
|
powerpc/eeh: No hotplug on permanently removed dev
The issue was detected in a bit complicated test case where
we have multiple hierarchical PEs shown as following figure:
+-----------------+
| PE#3 p2p#0 |
| p2p#1 |
+-----------------+
|
+-----------------+
| PE#4 pdev#0 |
| pdev#1 |
+-----------------+
PE#4 (have 2 PCI devices) is the child of PE#3, which has 2 p2p
bridges. We accidentally had less-known scenario: PE#4 was removed
permanently from the system because of permanent failure (e.g.
exceeding the max allowd failure times in last hour), then we detects
EEH errors on PE#3 and tried to recover it. However, eeh_dev instances
for pdev#0/1 were not detached from PE#4, which was still connected to
PE#3. All of that was because of the fact that we rely on count-based
pcibios_release_device(), which isn't reliable enough. When doing
recovery for PE#3, we still apply hotplug on PE#4 and pdev#0/1, which
are not valid any more. Eventually, we run into kernel crash.
The patch fixes above issue from two aspects. For unplug, we simply
skip those permanently removed PE, whose state is (EEH_PE_STATE_ISOLATED
&& !EEH_PE_STATE_RECOVERING) and its frozen count should be greater
than EEH_MAX_ALLOWED_FREEZES. For plug, we marked all permanently
removed EEH devices with EEH_DEV_REMOVED and return 0xFF's on read
its PCI config so that PCI core will omit them.
Signed-off-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-04-24 10:00:19 +02:00
|
|
|
return NULL;
|
2005-11-04 01:52:49 +01:00
|
|
|
dev->error_state = pci_channel_io_normal;
|
|
|
|
|
2012-09-17 06:34:27 +02:00
|
|
|
driver = eeh_pcid_get(dev);
|
|
|
|
if (!driver) return NULL;
|
2006-12-06 19:32:20 +01:00
|
|
|
|
2016-03-04 00:53:11 +01:00
|
|
|
was_in_error = edev->in_error;
|
|
|
|
edev->in_error = false;
|
2009-02-10 12:12:21 +01:00
|
|
|
eeh_enable_irq(dev);
|
|
|
|
|
2006-12-06 19:32:20 +01:00
|
|
|
if (!driver->err_handler ||
|
2014-01-12 07:13:45 +01:00
|
|
|
!driver->err_handler->resume ||
|
2016-03-04 00:53:11 +01:00
|
|
|
(edev->mode & EEH_DEV_NO_HANDLER) || !was_in_error) {
|
2014-01-12 07:13:45 +01:00
|
|
|
edev->mode &= ~EEH_DEV_NO_HANDLER;
|
2012-09-17 06:34:27 +02:00
|
|
|
eeh_pcid_put(dev);
|
2012-09-08 00:44:19 +02:00
|
|
|
return NULL;
|
2012-09-17 06:34:27 +02:00
|
|
|
}
|
2005-11-04 01:52:49 +01:00
|
|
|
|
|
|
|
driver->err_handler->resume(dev);
|
2009-06-16 07:34:38 +02:00
|
|
|
|
2012-09-17 06:34:27 +02:00
|
|
|
eeh_pcid_put(dev);
|
2012-09-08 00:44:19 +02:00
|
|
|
return NULL;
|
2005-11-04 01:52:49 +01:00
|
|
|
}
|
|
|
|
|
2006-09-16 01:56:35 +02:00
|
|
|
/**
|
2012-02-27 21:04:02 +01:00
|
|
|
* eeh_report_failure - Tell device driver that device is dead.
|
2012-09-08 00:44:19 +02:00
|
|
|
* @data: eeh device
|
2012-02-27 21:04:02 +01:00
|
|
|
* @userdata: return value
|
2006-09-16 01:56:35 +02:00
|
|
|
*
|
|
|
|
* This informs the device driver that the device is permanently
|
|
|
|
* dead, and that no further recovery attempts will be made on it.
|
|
|
|
*/
|
2012-09-08 00:44:19 +02:00
|
|
|
static void *eeh_report_failure(void *data, void *userdata)
|
2005-11-04 01:52:49 +01:00
|
|
|
{
|
2012-09-08 00:44:19 +02:00
|
|
|
struct eeh_dev *edev = (struct eeh_dev *)data;
|
|
|
|
struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
|
|
|
|
struct pci_driver *driver;
|
|
|
|
|
2016-03-04 00:53:12 +01:00
|
|
|
if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
|
powerpc/eeh: No hotplug on permanently removed dev
The issue was detected in a bit complicated test case where
we have multiple hierarchical PEs shown as following figure:
+-----------------+
| PE#3 p2p#0 |
| p2p#1 |
+-----------------+
|
+-----------------+
| PE#4 pdev#0 |
| pdev#1 |
+-----------------+
PE#4 (have 2 PCI devices) is the child of PE#3, which has 2 p2p
bridges. We accidentally had less-known scenario: PE#4 was removed
permanently from the system because of permanent failure (e.g.
exceeding the max allowd failure times in last hour), then we detects
EEH errors on PE#3 and tried to recover it. However, eeh_dev instances
for pdev#0/1 were not detached from PE#4, which was still connected to
PE#3. All of that was because of the fact that we rely on count-based
pcibios_release_device(), which isn't reliable enough. When doing
recovery for PE#3, we still apply hotplug on PE#4 and pdev#0/1, which
are not valid any more. Eventually, we run into kernel crash.
The patch fixes above issue from two aspects. For unplug, we simply
skip those permanently removed PE, whose state is (EEH_PE_STATE_ISOLATED
&& !EEH_PE_STATE_RECOVERING) and its frozen count should be greater
than EEH_MAX_ALLOWED_FREEZES. For plug, we marked all permanently
removed EEH devices with EEH_DEV_REMOVED and return 0xFF's on read
its PCI config so that PCI core will omit them.
Signed-off-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-04-24 10:00:19 +02:00
|
|
|
return NULL;
|
2005-11-04 01:52:49 +01:00
|
|
|
dev->error_state = pci_channel_io_perm_failure;
|
|
|
|
|
2012-09-17 06:34:27 +02:00
|
|
|
driver = eeh_pcid_get(dev);
|
|
|
|
if (!driver) return NULL;
|
2005-11-04 01:52:49 +01:00
|
|
|
|
2009-02-10 12:12:21 +01:00
|
|
|
eeh_disable_irq(dev);
|
|
|
|
|
|
|
|
if (!driver->err_handler ||
|
2012-09-17 06:34:27 +02:00
|
|
|
!driver->err_handler->error_detected) {
|
|
|
|
eeh_pcid_put(dev);
|
2012-09-08 00:44:19 +02:00
|
|
|
return NULL;
|
2012-09-17 06:34:27 +02:00
|
|
|
}
|
2009-02-10 12:12:21 +01:00
|
|
|
|
2005-11-04 01:52:49 +01:00
|
|
|
driver->err_handler->error_detected(dev, pci_channel_io_perm_failure);
|
2009-06-16 07:34:38 +02:00
|
|
|
|
2012-09-17 06:34:27 +02:00
|
|
|
eeh_pcid_put(dev);
|
2012-09-08 00:44:19 +02:00
|
|
|
return NULL;
|
2005-11-04 01:52:49 +01:00
|
|
|
}
|
|
|
|
|
2016-03-04 00:53:11 +01:00
|
|
|
static void *eeh_add_virt_device(void *data, void *userdata)
|
|
|
|
{
|
|
|
|
struct pci_driver *driver;
|
|
|
|
struct eeh_dev *edev = (struct eeh_dev *)data;
|
|
|
|
struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
|
|
|
|
struct pci_dn *pdn = eeh_dev_to_pdn(edev);
|
|
|
|
|
|
|
|
if (!(edev->physfn)) {
|
|
|
|
pr_warn("%s: EEH dev %04x:%02x:%02x.%01x not for VF\n",
|
|
|
|
__func__, edev->phb->global_number, pdn->busno,
|
|
|
|
PCI_SLOT(pdn->devfn), PCI_FUNC(pdn->devfn));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
driver = eeh_pcid_get(dev);
|
|
|
|
if (driver) {
|
|
|
|
eeh_pcid_put(dev);
|
|
|
|
if (driver->err_handler)
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC_POWERNV
|
|
|
|
pci_iov_add_virtfn(edev->physfn, pdn->vf_index, 0);
|
|
|
|
#endif
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
static void *eeh_rmv_device(void *data, void *userdata)
|
|
|
|
{
|
|
|
|
struct pci_driver *driver;
|
|
|
|
struct eeh_dev *edev = (struct eeh_dev *)data;
|
|
|
|
struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
|
2016-03-04 00:53:11 +01:00
|
|
|
struct eeh_rmv_data *rmv_data = (struct eeh_rmv_data *)userdata;
|
|
|
|
int *removed = rmv_data ? &rmv_data->removed : NULL;
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Actually, we should remove the PCI bridges as well.
|
|
|
|
* However, that's lots of complexity to do that,
|
|
|
|
* particularly some of devices under the bridge might
|
|
|
|
* support EEH. So we just care about PCI devices for
|
|
|
|
* simplicity here.
|
|
|
|
*/
|
2015-12-03 20:18:18 +01:00
|
|
|
if (!dev || (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE))
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
return NULL;
|
2014-02-05 19:20:45 +01:00
|
|
|
|
powerpc/eeh: No hotplug on permanently removed dev
The issue was detected in a bit complicated test case where
we have multiple hierarchical PEs shown as following figure:
+-----------------+
| PE#3 p2p#0 |
| p2p#1 |
+-----------------+
|
+-----------------+
| PE#4 pdev#0 |
| pdev#1 |
+-----------------+
PE#4 (have 2 PCI devices) is the child of PE#3, which has 2 p2p
bridges. We accidentally had less-known scenario: PE#4 was removed
permanently from the system because of permanent failure (e.g.
exceeding the max allowd failure times in last hour), then we detects
EEH errors on PE#3 and tried to recover it. However, eeh_dev instances
for pdev#0/1 were not detached from PE#4, which was still connected to
PE#3. All of that was because of the fact that we rely on count-based
pcibios_release_device(), which isn't reliable enough. When doing
recovery for PE#3, we still apply hotplug on PE#4 and pdev#0/1, which
are not valid any more. Eventually, we run into kernel crash.
The patch fixes above issue from two aspects. For unplug, we simply
skip those permanently removed PE, whose state is (EEH_PE_STATE_ISOLATED
&& !EEH_PE_STATE_RECOVERING) and its frozen count should be greater
than EEH_MAX_ALLOWED_FREEZES. For plug, we marked all permanently
removed EEH devices with EEH_DEV_REMOVED and return 0xFF's on read
its PCI config so that PCI core will omit them.
Signed-off-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-04-24 10:00:19 +02:00
|
|
|
/*
|
|
|
|
* We rely on count-based pcibios_release_device() to
|
|
|
|
* detach permanently offlined PEs. Unfortunately, that's
|
|
|
|
* not reliable enough. We might have the permanently
|
|
|
|
* offlined PEs attached, but we needn't take care of
|
|
|
|
* them and their child devices.
|
|
|
|
*/
|
|
|
|
if (eeh_dev_removed(edev))
|
|
|
|
return NULL;
|
|
|
|
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
driver = eeh_pcid_get(dev);
|
2014-02-05 19:20:45 +01:00
|
|
|
if (driver) {
|
|
|
|
eeh_pcid_put(dev);
|
2016-03-04 00:53:13 +01:00
|
|
|
if (removed &&
|
|
|
|
eeh_pe_passed(edev->pe))
|
|
|
|
return NULL;
|
2016-03-04 00:53:11 +01:00
|
|
|
if (removed &&
|
|
|
|
driver->err_handler &&
|
2015-10-08 05:58:53 +02:00
|
|
|
driver->err_handler->error_detected &&
|
2016-02-12 06:03:05 +01:00
|
|
|
driver->err_handler->slot_reset)
|
2014-02-05 19:20:45 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
|
|
|
|
/* Remove it from PCI subsystem */
|
|
|
|
pr_debug("EEH: Removing %s without EEH sensitive driver\n",
|
|
|
|
pci_name(dev));
|
|
|
|
edev->bus = dev->bus;
|
|
|
|
edev->mode |= EEH_DEV_DISCONNECTED;
|
2016-03-04 00:53:11 +01:00
|
|
|
if (removed)
|
|
|
|
(*removed)++;
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
|
2016-03-04 00:53:11 +01:00
|
|
|
if (edev->physfn) {
|
|
|
|
#ifdef CONFIG_PPC_POWERNV
|
|
|
|
struct pci_dn *pdn = eeh_dev_to_pdn(edev);
|
|
|
|
|
|
|
|
pci_iov_remove_virtfn(edev->physfn, pdn->vf_index, 0);
|
|
|
|
edev->pdev = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have to set the VF PE number to invalid one, which is
|
|
|
|
* required to plug the VF successfully.
|
|
|
|
*/
|
|
|
|
pdn->pe_number = IODA_INVALID_PE;
|
|
|
|
#endif
|
|
|
|
if (rmv_data)
|
|
|
|
list_add(&edev->rmv_list, &rmv_data->edev_list);
|
|
|
|
} else {
|
|
|
|
pci_lock_rescan_remove();
|
|
|
|
pci_stop_and_remove_bus_device(dev);
|
|
|
|
pci_unlock_rescan_remove();
|
|
|
|
}
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *eeh_pe_detach_dev(void *data, void *userdata)
|
|
|
|
{
|
|
|
|
struct eeh_pe *pe = (struct eeh_pe *)data;
|
|
|
|
struct eeh_dev *edev, *tmp;
|
|
|
|
|
|
|
|
eeh_pe_for_each_dev(pe, edev, tmp) {
|
|
|
|
if (!(edev->mode & EEH_DEV_DISCONNECTED))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
edev->mode &= ~(EEH_DEV_DISCONNECTED | EEH_DEV_IRQ_DISABLED);
|
|
|
|
eeh_rmv_from_parent_pe(edev);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-04-24 10:00:14 +02:00
|
|
|
/*
|
|
|
|
* Explicitly clear PE's frozen state for PowerNV where
|
|
|
|
* we have frozen PE until BAR restore is completed. It's
|
|
|
|
* harmless to clear it for pSeries. To be consistent with
|
|
|
|
* PE reset (for 3 times), we try to clear the frozen state
|
|
|
|
* for 3 times as well.
|
|
|
|
*/
|
2014-05-05 01:29:02 +02:00
|
|
|
static void *__eeh_clear_pe_frozen_state(void *data, void *flag)
|
2014-04-24 10:00:14 +02:00
|
|
|
{
|
2014-05-05 01:29:02 +02:00
|
|
|
struct eeh_pe *pe = (struct eeh_pe *)data;
|
2017-01-19 00:10:16 +01:00
|
|
|
bool clear_sw_state = *(bool *)flag;
|
2014-09-30 04:39:02 +02:00
|
|
|
int i, rc = 1;
|
2014-04-24 10:00:14 +02:00
|
|
|
|
2014-09-30 04:39:02 +02:00
|
|
|
for (i = 0; rc && i < 3; i++)
|
2014-09-30 04:39:07 +02:00
|
|
|
rc = eeh_unfreeze_pe(pe, clear_sw_state);
|
2014-04-24 10:00:14 +02:00
|
|
|
|
2014-09-30 04:39:02 +02:00
|
|
|
/* Stop immediately on any errors */
|
2014-05-05 01:29:02 +02:00
|
|
|
if (rc) {
|
2014-09-30 04:39:02 +02:00
|
|
|
pr_warn("%s: Failure %d unfreezing PHB#%x-PE#%x\n",
|
|
|
|
__func__, rc, pe->phb->global_number, pe->addr);
|
2014-05-05 01:29:02 +02:00
|
|
|
return (void *)pe;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-09-30 04:39:07 +02:00
|
|
|
static int eeh_clear_pe_frozen_state(struct eeh_pe *pe,
|
|
|
|
bool clear_sw_state)
|
2014-05-05 01:29:02 +02:00
|
|
|
{
|
|
|
|
void *rc;
|
|
|
|
|
2014-09-30 04:39:07 +02:00
|
|
|
rc = eeh_pe_traverse(pe, __eeh_clear_pe_frozen_state, &clear_sw_state);
|
2014-05-05 01:29:02 +02:00
|
|
|
if (!rc)
|
2014-04-24 10:00:14 +02:00
|
|
|
eeh_pe_state_clear(pe, EEH_PE_ISOLATED);
|
|
|
|
|
2014-05-05 01:29:02 +02:00
|
|
|
return rc ? -EIO : 0;
|
2014-04-24 10:00:14 +02:00
|
|
|
}
|
|
|
|
|
2014-09-30 04:39:07 +02:00
|
|
|
int eeh_pe_reset_and_recover(struct eeh_pe *pe)
|
|
|
|
{
|
2016-04-27 03:14:52 +02:00
|
|
|
int ret;
|
2014-09-30 04:39:07 +02:00
|
|
|
|
|
|
|
/* Bail if the PE is being recovered */
|
|
|
|
if (pe->state & EEH_PE_RECOVERING)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Put the PE into recovery mode */
|
|
|
|
eeh_pe_state_mark(pe, EEH_PE_RECOVERING);
|
|
|
|
|
|
|
|
/* Save states */
|
|
|
|
eeh_pe_dev_traverse(pe, eeh_dev_save_state, NULL);
|
|
|
|
|
|
|
|
/* Issue reset */
|
2016-11-17 06:07:47 +01:00
|
|
|
ret = eeh_pe_reset_full(pe);
|
2014-09-30 04:39:07 +02:00
|
|
|
if (ret) {
|
2014-11-14 00:47:29 +01:00
|
|
|
eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
|
2014-09-30 04:39:07 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Unfreeze the PE */
|
|
|
|
ret = eeh_clear_pe_frozen_state(pe, true);
|
|
|
|
if (ret) {
|
|
|
|
eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Restore device state */
|
|
|
|
eeh_pe_dev_traverse(pe, eeh_dev_restore_state, NULL);
|
|
|
|
|
|
|
|
/* Clear recovery mode */
|
|
|
|
eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-04 01:52:49 +01:00
|
|
|
/**
|
2012-02-27 21:04:02 +01:00
|
|
|
* eeh_reset_device - Perform actual reset of a pci slot
|
2012-09-08 00:44:19 +02:00
|
|
|
* @pe: EEH PE
|
2012-02-27 21:04:02 +01:00
|
|
|
* @bus: PCI bus corresponding to the isolcated slot
|
2005-11-04 01:52:49 +01:00
|
|
|
*
|
2012-02-27 21:04:02 +01:00
|
|
|
* This routine must be called to do reset on the indicated PE.
|
|
|
|
* During the reset, udev might be invoked because those affected
|
|
|
|
* PCI devices will be removed and then added.
|
2005-11-04 01:52:49 +01:00
|
|
|
*/
|
2016-03-04 00:53:11 +01:00
|
|
|
static int eeh_reset_device(struct eeh_pe *pe, struct pci_bus *bus,
|
|
|
|
struct eeh_rmv_data *rmv_data)
|
2005-11-04 01:52:49 +01:00
|
|
|
{
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
struct pci_bus *frozen_bus = eeh_pe_bus_get(pe);
|
2013-06-20 07:21:01 +02:00
|
|
|
struct timeval tstamp;
|
2016-03-04 00:53:11 +01:00
|
|
|
int cnt, rc;
|
|
|
|
struct eeh_dev *edev;
|
2006-04-29 00:39:38 +02:00
|
|
|
|
|
|
|
/* pcibios will clear the counter; save the value */
|
2012-09-08 00:44:19 +02:00
|
|
|
cnt = pe->freeze_count;
|
2013-06-20 07:21:01 +02:00
|
|
|
tstamp = pe->tstamp;
|
2006-04-29 00:39:38 +02:00
|
|
|
|
2012-09-11 21:16:17 +02:00
|
|
|
/*
|
|
|
|
* We don't remove the corresponding PE instances because
|
|
|
|
* we need the information afterwords. The attached EEH
|
|
|
|
* devices are expected to be attached soon when calling
|
2016-05-03 07:41:37 +02:00
|
|
|
* into pci_hp_add_devices().
|
2012-09-11 21:16:17 +02:00
|
|
|
*/
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
eeh_pe_state_mark(pe, EEH_PE_KEEP);
|
2014-01-15 14:33:20 +01:00
|
|
|
if (bus) {
|
2016-03-04 00:53:11 +01:00
|
|
|
if (pe->type & EEH_PE_VF) {
|
|
|
|
eeh_pe_dev_traverse(pe, eeh_rmv_device, NULL);
|
|
|
|
} else {
|
|
|
|
pci_lock_rescan_remove();
|
2016-05-03 07:41:37 +02:00
|
|
|
pci_hp_remove_devices(bus);
|
2016-03-04 00:53:11 +01:00
|
|
|
pci_unlock_rescan_remove();
|
|
|
|
}
|
2014-01-15 14:33:20 +01:00
|
|
|
} else if (frozen_bus) {
|
2016-06-24 06:49:02 +02:00
|
|
|
eeh_pe_dev_traverse(pe, eeh_rmv_device, rmv_data);
|
2014-01-15 14:33:20 +01:00
|
|
|
}
|
2005-11-04 01:52:49 +01:00
|
|
|
|
2014-04-24 10:00:12 +02:00
|
|
|
/*
|
|
|
|
* Reset the pci controller. (Asserts RST#; resets config space).
|
2005-11-04 01:54:54 +01:00
|
|
|
* Reconfigure bridges and devices. Don't try to bring the system
|
2012-02-27 21:04:02 +01:00
|
|
|
* up if the reset failed for some reason.
|
2014-04-24 10:00:12 +02:00
|
|
|
*
|
|
|
|
* During the reset, it's very dangerous to have uncontrolled PCI
|
|
|
|
* config accesses. So we prefer to block them. However, controlled
|
|
|
|
* PCI config accesses initiated from EEH itself are allowed.
|
2012-02-27 21:04:02 +01:00
|
|
|
*/
|
2016-11-17 06:07:47 +01:00
|
|
|
rc = eeh_pe_reset_full(pe);
|
2014-11-14 00:47:29 +01:00
|
|
|
if (rc)
|
2005-11-04 01:54:54 +01:00
|
|
|
return rc;
|
2005-11-04 01:52:49 +01:00
|
|
|
|
2014-01-15 14:33:20 +01:00
|
|
|
pci_lock_rescan_remove();
|
|
|
|
|
2012-09-08 00:44:19 +02:00
|
|
|
/* Restore PE */
|
|
|
|
eeh_ops->configure_bridge(pe);
|
|
|
|
eeh_pe_restore_bars(pe);
|
2005-11-04 01:52:49 +01:00
|
|
|
|
Revert "powerpc/eeh: Don't unfreeze PHB PE after reset"
This reverts commit 527d10ef3a315d3cb9dc098dacd61889a6c26439.
The reverted commit breaks cxlflash devices following an EEH reset (and
possibly other cxl devices, however this has not been tested).
The reverted commit changed the behaviour of eeh_reset_device() so that PHB
PEs are not unfrozen following the completion of the reset. This should not
be problematic, as no device resources should have been associated with the
PHB PE.
However, when attempting to load the cxlflash driver after a reset, the
driver attempts to read Vital Product Data through a call to
pci_read_vpd() (which is called on the physical cxl device, not on the
virtual AFU device). pci_read_vpd() in turn attempts to read from the cxl
device's config space. This fails, as the PE it's trying to read from is
still frozen. In turn, the driver gets an -ENODEV and fails to initialise.
It appears this issue only affects some parts of the VPD area, as "lspci
-vvv", which only reads a subset of the VPD bytes, is not broken by the
original patch.
At this stage, we don't fully understand why we're trying to read a frozen
PE, and we don't know how this affects other cxl devices. It is possible
that there is an underlying bug in the cxl driver or the powerpc CAPI
support code, or alternatively a bug in the PCI resource allocation/mapping
code that is incorrectly mapping resources to PE#0.
As such, this fix is incomplete, however it is necessary to prevent a
serious regression in CAPI support.
In the meantime, revert the commit, especially as it was intended to be a
non-functional change.
Cc: Gavin Shan <gwshan@linux.vnet.ibm.com>
Cc: Ian Munsie <imunsie@au1.ibm.com>
Cc: Daniel Axtens <dja@axtens.net>
Signed-off-by: Andrew Donnellan <andrew.donnellan@au1.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2015-12-08 06:59:25 +01:00
|
|
|
/* Clear frozen state */
|
|
|
|
rc = eeh_clear_pe_frozen_state(pe, false);
|
2016-12-01 01:23:05 +01:00
|
|
|
if (rc) {
|
|
|
|
pci_unlock_rescan_remove();
|
Revert "powerpc/eeh: Don't unfreeze PHB PE after reset"
This reverts commit 527d10ef3a315d3cb9dc098dacd61889a6c26439.
The reverted commit breaks cxlflash devices following an EEH reset (and
possibly other cxl devices, however this has not been tested).
The reverted commit changed the behaviour of eeh_reset_device() so that PHB
PEs are not unfrozen following the completion of the reset. This should not
be problematic, as no device resources should have been associated with the
PHB PE.
However, when attempting to load the cxlflash driver after a reset, the
driver attempts to read Vital Product Data through a call to
pci_read_vpd() (which is called on the physical cxl device, not on the
virtual AFU device). pci_read_vpd() in turn attempts to read from the cxl
device's config space. This fails, as the PE it's trying to read from is
still frozen. In turn, the driver gets an -ENODEV and fails to initialise.
It appears this issue only affects some parts of the VPD area, as "lspci
-vvv", which only reads a subset of the VPD bytes, is not broken by the
original patch.
At this stage, we don't fully understand why we're trying to read a frozen
PE, and we don't know how this affects other cxl devices. It is possible
that there is an underlying bug in the cxl driver or the powerpc CAPI
support code, or alternatively a bug in the PCI resource allocation/mapping
code that is incorrectly mapping resources to PE#0.
As such, this fix is incomplete, however it is necessary to prevent a
serious regression in CAPI support.
In the meantime, revert the commit, especially as it was intended to be a
non-functional change.
Cc: Gavin Shan <gwshan@linux.vnet.ibm.com>
Cc: Ian Munsie <imunsie@au1.ibm.com>
Cc: Daniel Axtens <dja@axtens.net>
Signed-off-by: Andrew Donnellan <andrew.donnellan@au1.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2015-12-08 06:59:25 +01:00
|
|
|
return rc;
|
2016-12-01 01:23:05 +01:00
|
|
|
}
|
2014-04-24 10:00:14 +02:00
|
|
|
|
2005-11-04 01:52:49 +01:00
|
|
|
/* Give the system 5 seconds to finish running the user-space
|
2013-06-20 07:20:51 +02:00
|
|
|
* hotplug shutdown scripts, e.g. ifdown for ethernet. Yes,
|
|
|
|
* this is a hack, but if we don't do this, and try to bring
|
|
|
|
* the device up before the scripts have taken it down,
|
2005-11-04 01:52:49 +01:00
|
|
|
* potentially weird things happen.
|
|
|
|
*/
|
|
|
|
if (bus) {
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
pr_info("EEH: Sleep 5s ahead of complete hotplug\n");
|
2012-02-27 21:04:02 +01:00
|
|
|
ssleep(5);
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The EEH device is still connected with its parent
|
|
|
|
* PE. We should disconnect it so the binding can be
|
|
|
|
* rebuilt when adding PCI devices.
|
|
|
|
*/
|
2016-03-04 00:53:11 +01:00
|
|
|
edev = list_first_entry(&pe->edevs, struct eeh_dev, list);
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
|
2016-06-17 05:05:11 +02:00
|
|
|
if (pe->type & EEH_PE_VF) {
|
2016-03-04 00:53:11 +01:00
|
|
|
eeh_add_virt_device(edev, NULL);
|
2016-06-17 05:05:11 +02:00
|
|
|
} else {
|
|
|
|
eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
|
2016-05-03 07:41:37 +02:00
|
|
|
pci_hp_add_devices(bus);
|
2016-06-17 05:05:11 +02:00
|
|
|
}
|
2016-03-04 00:53:11 +01:00
|
|
|
} else if (frozen_bus && rmv_data->removed) {
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
pr_info("EEH: Sleep 5s ahead of partial hotplug\n");
|
|
|
|
ssleep(5);
|
|
|
|
|
2016-03-04 00:53:11 +01:00
|
|
|
edev = list_first_entry(&pe->edevs, struct eeh_dev, list);
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
|
2016-03-04 00:53:11 +01:00
|
|
|
if (pe->type & EEH_PE_VF)
|
|
|
|
eeh_add_virt_device(edev, NULL);
|
|
|
|
else
|
2016-05-03 07:41:37 +02:00
|
|
|
pci_hp_add_devices(frozen_bus);
|
2005-11-04 01:52:49 +01:00
|
|
|
}
|
powerpc/eeh: Use partial hotplug for EEH unaware drivers
When EEH error happens to one specific PE, some devices with drivers
supporting EEH won't except hotplug on the device. However, there
might have other deivces without driver, or with driver without EEH
support. For the case, we need do partial hotplug in order to make
sure that the PE becomes absolutely quite during reset. Otherise,
the PE reset might fail and leads to failure of error recovery.
The current code doesn't handle that 'mixed' case properly, it either
uses the error callbacks to the drivers, or tries hotplug, but doesn't
handle a PE (EEH domain) composed of a combination of the two.
The patch intends to support so-called "partial" hotplug for EEH:
Before we do reset, we stop and remove those PCI devices without
EEH sensitive driver. The corresponding EEH devices are not detached
from its PE, but with special flag. After the reset is done, those
EEH devices with the special flag will be scanned one by one.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-07-24 04:24:58 +02:00
|
|
|
eeh_pe_state_clear(pe, EEH_PE_KEEP);
|
2013-06-20 07:21:01 +02:00
|
|
|
|
|
|
|
pe->tstamp = tstamp;
|
2012-09-08 00:44:19 +02:00
|
|
|
pe->freeze_count = cnt;
|
2005-11-04 01:54:54 +01:00
|
|
|
|
2014-01-15 14:33:20 +01:00
|
|
|
pci_unlock_rescan_remove();
|
2005-11-04 01:54:54 +01:00
|
|
|
return 0;
|
2005-11-04 01:52:49 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* The longest amount of time to wait for a pci device
|
|
|
|
* to come back on line, in seconds.
|
|
|
|
*/
|
2013-11-25 23:27:54 +01:00
|
|
|
#define MAX_WAIT_FOR_RECOVERY 300
|
2005-11-04 01:52:49 +01:00
|
|
|
|
2017-04-19 09:39:27 +02:00
|
|
|
/**
|
|
|
|
* eeh_handle_normal_event - Handle EEH events on a specific PE
|
|
|
|
* @pe: EEH PE
|
|
|
|
*
|
|
|
|
* Attempts to recover the given PE. If recovery fails or the PE has failed
|
|
|
|
* too many times, remove the PE.
|
|
|
|
*
|
|
|
|
* Returns true if @pe should no longer be used, else false.
|
|
|
|
*/
|
2017-04-19 09:39:26 +02:00
|
|
|
static bool eeh_handle_normal_event(struct eeh_pe *pe)
|
2005-11-04 01:52:49 +01:00
|
|
|
{
|
|
|
|
struct pci_bus *frozen_bus;
|
2016-03-04 00:53:11 +01:00
|
|
|
struct eeh_dev *edev, *tmp;
|
2005-11-04 01:54:54 +01:00
|
|
|
int rc = 0;
|
2005-11-29 07:17:02 +01:00
|
|
|
enum pci_ers_result result = PCI_ERS_RESULT_NONE;
|
2016-03-04 00:53:11 +01:00
|
|
|
struct eeh_rmv_data rmv_data = {LIST_HEAD_INIT(rmv_data.edev_list), 0};
|
2005-11-04 01:52:49 +01:00
|
|
|
|
2012-09-08 00:44:19 +02:00
|
|
|
frozen_bus = eeh_pe_bus_get(pe);
|
2005-11-04 01:52:49 +01:00
|
|
|
if (!frozen_bus) {
|
2016-11-16 04:02:15 +01:00
|
|
|
pr_err("%s: Cannot find PCI bus for PHB#%x-PE#%x\n",
|
2012-09-08 00:44:19 +02:00
|
|
|
__func__, pe->phb->global_number, pe->addr);
|
2017-04-19 09:39:26 +02:00
|
|
|
return false;
|
2005-11-04 01:52:49 +01:00
|
|
|
}
|
|
|
|
|
2013-06-20 07:21:01 +02:00
|
|
|
eeh_pe_update_time_stamp(pe);
|
2012-09-08 00:44:19 +02:00
|
|
|
pe->freeze_count++;
|
2017-04-19 09:39:27 +02:00
|
|
|
if (pe->freeze_count > eeh_max_freezes) {
|
|
|
|
pr_err("EEH: PHB#%x-PE#%x has failed %d times in the\n"
|
|
|
|
"last hour and has been permanently disabled.\n",
|
|
|
|
pe->phb->global_number, pe->addr,
|
|
|
|
pe->freeze_count);
|
|
|
|
goto hard_fail;
|
|
|
|
}
|
2014-07-17 06:41:41 +02:00
|
|
|
pr_warn("EEH: This PCI device has failed %d times in the last hour\n",
|
2012-09-08 00:44:19 +02:00
|
|
|
pe->freeze_count);
|
2005-11-04 01:52:49 +01:00
|
|
|
|
|
|
|
/* Walk the various device drivers attached to this slot through
|
|
|
|
* a reset sequence, giving each an opportunity to do what it needs
|
|
|
|
* to accomplish the reset. Each child gets a report of the
|
|
|
|
* status ... if any child can't handle the reset, then the entire
|
|
|
|
* slot is dlpar removed and added.
|
2015-10-08 05:58:54 +02:00
|
|
|
*
|
|
|
|
* When the PHB is fenced, we have to issue a reset to recover from
|
|
|
|
* the error. Override the result if necessary to have partially
|
|
|
|
* hotplug for this case.
|
2005-11-04 01:52:49 +01:00
|
|
|
*/
|
2013-06-27 07:46:46 +02:00
|
|
|
pr_info("EEH: Notify device drivers to shutdown\n");
|
2012-09-08 00:44:19 +02:00
|
|
|
eeh_pe_dev_traverse(pe, eeh_report_error, &result);
|
2015-10-08 05:58:54 +02:00
|
|
|
if ((pe->type & EEH_PE_PHB) &&
|
|
|
|
result != PCI_ERS_RESULT_NONE &&
|
|
|
|
result != PCI_ERS_RESULT_NEED_RESET)
|
|
|
|
result = PCI_ERS_RESULT_NEED_RESET;
|
2005-11-04 01:52:49 +01:00
|
|
|
|
2007-11-15 19:58:36 +01:00
|
|
|
/* Get the current PCI slot state. This can take a long time,
|
2015-04-27 03:25:10 +02:00
|
|
|
* sometimes over 300 seconds for certain systems.
|
2012-02-27 21:04:02 +01:00
|
|
|
*/
|
2012-09-08 00:44:19 +02:00
|
|
|
rc = eeh_ops->wait_state(pe, MAX_WAIT_FOR_RECOVERY*1000);
|
2012-02-27 21:03:57 +01:00
|
|
|
if (rc < 0 || rc == EEH_STATE_NOT_SUPPORT) {
|
2014-07-17 06:41:41 +02:00
|
|
|
pr_warn("EEH: Permanent failure\n");
|
2007-11-15 19:58:36 +01:00
|
|
|
goto hard_fail;
|
|
|
|
}
|
|
|
|
|
2007-05-09 01:33:29 +02:00
|
|
|
/* Since rtas may enable MMIO when posting the error log,
|
|
|
|
* don't post the error log until after all dev drivers
|
2007-05-09 18:38:11 +02:00
|
|
|
* have been informed.
|
|
|
|
*/
|
2013-06-27 07:46:46 +02:00
|
|
|
pr_info("EEH: Collect temporary log\n");
|
2012-09-08 00:44:19 +02:00
|
|
|
eeh_slot_error_detail(pe, EEH_LOG_TEMP);
|
2007-05-09 01:33:29 +02:00
|
|
|
|
2005-11-04 01:52:49 +01:00
|
|
|
/* If all device drivers were EEH-unaware, then shut
|
|
|
|
* down all of the device drivers, and hope they
|
|
|
|
* go down willingly, without panicing the system.
|
|
|
|
*/
|
2005-11-29 07:17:02 +01:00
|
|
|
if (result == PCI_ERS_RESULT_NONE) {
|
2013-06-27 07:46:46 +02:00
|
|
|
pr_info("EEH: Reset with hotplug activity\n");
|
2016-03-04 00:53:11 +01:00
|
|
|
rc = eeh_reset_device(pe, frozen_bus, NULL);
|
2007-03-19 20:52:04 +01:00
|
|
|
if (rc) {
|
2014-07-17 06:41:41 +02:00
|
|
|
pr_warn("%s: Unable to reset, err=%d\n",
|
|
|
|
__func__, rc);
|
2005-11-04 01:54:54 +01:00
|
|
|
goto hard_fail;
|
2007-03-19 20:52:04 +01:00
|
|
|
}
|
2005-11-04 01:52:49 +01:00
|
|
|
}
|
|
|
|
|
2006-09-16 01:58:59 +02:00
|
|
|
/* If all devices reported they can proceed, then re-enable MMIO */
|
|
|
|
if (result == PCI_ERS_RESULT_CAN_RECOVER) {
|
2013-06-27 07:46:46 +02:00
|
|
|
pr_info("EEH: Enable I/O for affected devices\n");
|
2012-09-08 00:44:19 +02:00
|
|
|
rc = eeh_pci_enable(pe, EEH_OPT_THAW_MMIO);
|
2006-09-16 01:58:59 +02:00
|
|
|
|
2007-03-19 20:59:59 +01:00
|
|
|
if (rc < 0)
|
|
|
|
goto hard_fail;
|
2006-09-16 01:58:59 +02:00
|
|
|
if (rc) {
|
|
|
|
result = PCI_ERS_RESULT_NEED_RESET;
|
|
|
|
} else {
|
2013-06-27 07:46:46 +02:00
|
|
|
pr_info("EEH: Notify device drivers to resume I/O\n");
|
2012-09-08 00:44:19 +02:00
|
|
|
eeh_pe_dev_traverse(pe, eeh_report_mmio_enabled, &result);
|
2006-09-16 01:58:59 +02:00
|
|
|
}
|
2005-11-04 01:52:49 +01:00
|
|
|
}
|
|
|
|
|
2006-09-16 01:58:59 +02:00
|
|
|
/* If all devices reported they can proceed, then re-enable DMA */
|
2005-11-29 07:17:02 +01:00
|
|
|
if (result == PCI_ERS_RESULT_CAN_RECOVER) {
|
2013-06-27 07:46:46 +02:00
|
|
|
pr_info("EEH: Enabled DMA for affected devices\n");
|
2012-09-08 00:44:19 +02:00
|
|
|
rc = eeh_pci_enable(pe, EEH_OPT_THAW_DMA);
|
2006-09-16 01:58:59 +02:00
|
|
|
|
2007-03-19 20:59:59 +01:00
|
|
|
if (rc < 0)
|
|
|
|
goto hard_fail;
|
2014-04-24 10:00:26 +02:00
|
|
|
if (rc) {
|
2006-09-16 01:58:59 +02:00
|
|
|
result = PCI_ERS_RESULT_NEED_RESET;
|
2014-04-24 10:00:26 +02:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We didn't do PE reset for the case. The PE
|
|
|
|
* is still in frozen state. Clear it before
|
|
|
|
* resuming the PE.
|
|
|
|
*/
|
|
|
|
eeh_pe_state_clear(pe, EEH_PE_ISOLATED);
|
2006-12-06 19:32:20 +01:00
|
|
|
result = PCI_ERS_RESULT_RECOVERED;
|
2014-04-24 10:00:26 +02:00
|
|
|
}
|
2006-09-16 01:58:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If any device has a hard failure, then shut off everything. */
|
2007-03-19 20:52:04 +01:00
|
|
|
if (result == PCI_ERS_RESULT_DISCONNECT) {
|
2014-07-17 06:41:41 +02:00
|
|
|
pr_warn("EEH: Device driver gave up\n");
|
2006-09-16 01:58:59 +02:00
|
|
|
goto hard_fail;
|
2007-03-19 20:52:04 +01:00
|
|
|
}
|
2006-09-16 01:58:59 +02:00
|
|
|
|
|
|
|
/* If any device called out for a reset, then reset the slot */
|
|
|
|
if (result == PCI_ERS_RESULT_NEED_RESET) {
|
2013-06-27 07:46:46 +02:00
|
|
|
pr_info("EEH: Reset without hotplug activity\n");
|
2016-03-04 00:53:11 +01:00
|
|
|
rc = eeh_reset_device(pe, NULL, &rmv_data);
|
2007-03-19 20:52:04 +01:00
|
|
|
if (rc) {
|
2014-07-17 06:41:41 +02:00
|
|
|
pr_warn("%s: Cannot reset, err=%d\n",
|
|
|
|
__func__, rc);
|
2005-11-04 01:54:54 +01:00
|
|
|
goto hard_fail;
|
2007-03-19 20:52:04 +01:00
|
|
|
}
|
2013-06-27 07:46:46 +02:00
|
|
|
|
|
|
|
pr_info("EEH: Notify device drivers "
|
|
|
|
"the completion of reset\n");
|
2006-09-16 01:58:59 +02:00
|
|
|
result = PCI_ERS_RESULT_NONE;
|
2012-09-08 00:44:19 +02:00
|
|
|
eeh_pe_dev_traverse(pe, eeh_report_reset, &result);
|
2005-11-04 01:52:49 +01:00
|
|
|
}
|
|
|
|
|
2006-09-16 01:58:59 +02:00
|
|
|
/* All devices should claim they have recovered by now. */
|
2007-03-19 20:55:10 +01:00
|
|
|
if ((result != PCI_ERS_RESULT_RECOVERED) &&
|
|
|
|
(result != PCI_ERS_RESULT_NONE)) {
|
2014-07-17 06:41:41 +02:00
|
|
|
pr_warn("EEH: Not recovered\n");
|
2006-09-16 01:58:59 +02:00
|
|
|
goto hard_fail;
|
2007-03-19 20:52:04 +01:00
|
|
|
}
|
2006-09-16 01:58:59 +02:00
|
|
|
|
2016-03-04 00:53:11 +01:00
|
|
|
/*
|
|
|
|
* For those hot removed VFs, we should add back them after PF get
|
|
|
|
* recovered properly.
|
|
|
|
*/
|
|
|
|
list_for_each_entry_safe(edev, tmp, &rmv_data.edev_list, rmv_list) {
|
|
|
|
eeh_add_virt_device(edev, NULL);
|
|
|
|
list_del(&edev->rmv_list);
|
|
|
|
}
|
|
|
|
|
2005-11-04 01:52:49 +01:00
|
|
|
/* Tell all device drivers that they can resume operations */
|
2013-06-27 07:46:46 +02:00
|
|
|
pr_info("EEH: Notify device driver to resume\n");
|
2012-09-08 00:44:19 +02:00
|
|
|
eeh_pe_dev_traverse(pe, eeh_report_resume, NULL);
|
2005-11-04 01:54:54 +01:00
|
|
|
|
2017-04-19 09:39:26 +02:00
|
|
|
return false;
|
2013-06-20 07:20:51 +02:00
|
|
|
|
2017-04-19 09:39:27 +02:00
|
|
|
hard_fail:
|
2005-11-04 01:54:54 +01:00
|
|
|
/*
|
|
|
|
* About 90% of all real-life EEH failures in the field
|
|
|
|
* are due to poorly seated PCI cards. Only 10% or so are
|
|
|
|
* due to actual, failed cards.
|
|
|
|
*/
|
2016-11-16 04:02:15 +01:00
|
|
|
pr_err("EEH: Unable to recover from failure from PHB#%x-PE#%x.\n"
|
2012-09-08 00:44:19 +02:00
|
|
|
"Please try reseating or replacing it\n",
|
|
|
|
pe->phb->global_number, pe->addr);
|
2005-11-04 01:54:54 +01:00
|
|
|
|
2012-09-08 00:44:19 +02:00
|
|
|
eeh_slot_error_detail(pe, EEH_LOG_PERM);
|
2005-11-04 01:54:54 +01:00
|
|
|
|
|
|
|
/* Notify all devices that they're about to go down. */
|
2012-09-08 00:44:19 +02:00
|
|
|
eeh_pe_dev_traverse(pe, eeh_report_failure, NULL);
|
2005-11-04 01:54:54 +01:00
|
|
|
|
powerpc/eeh: No hotplug on permanently removed dev
The issue was detected in a bit complicated test case where
we have multiple hierarchical PEs shown as following figure:
+-----------------+
| PE#3 p2p#0 |
| p2p#1 |
+-----------------+
|
+-----------------+
| PE#4 pdev#0 |
| pdev#1 |
+-----------------+
PE#4 (have 2 PCI devices) is the child of PE#3, which has 2 p2p
bridges. We accidentally had less-known scenario: PE#4 was removed
permanently from the system because of permanent failure (e.g.
exceeding the max allowd failure times in last hour), then we detects
EEH errors on PE#3 and tried to recover it. However, eeh_dev instances
for pdev#0/1 were not detached from PE#4, which was still connected to
PE#3. All of that was because of the fact that we rely on count-based
pcibios_release_device(), which isn't reliable enough. When doing
recovery for PE#3, we still apply hotplug on PE#4 and pdev#0/1, which
are not valid any more. Eventually, we run into kernel crash.
The patch fixes above issue from two aspects. For unplug, we simply
skip those permanently removed PE, whose state is (EEH_PE_STATE_ISOLATED
&& !EEH_PE_STATE_RECOVERING) and its frozen count should be greater
than EEH_MAX_ALLOWED_FREEZES. For plug, we marked all permanently
removed EEH devices with EEH_DEV_REMOVED and return 0xFF's on read
its PCI config so that PCI core will omit them.
Signed-off-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-04-24 10:00:19 +02:00
|
|
|
/* Mark the PE to be removed permanently */
|
2014-12-11 04:28:55 +01:00
|
|
|
eeh_pe_state_mark(pe, EEH_PE_REMOVED);
|
powerpc/eeh: No hotplug on permanently removed dev
The issue was detected in a bit complicated test case where
we have multiple hierarchical PEs shown as following figure:
+-----------------+
| PE#3 p2p#0 |
| p2p#1 |
+-----------------+
|
+-----------------+
| PE#4 pdev#0 |
| pdev#1 |
+-----------------+
PE#4 (have 2 PCI devices) is the child of PE#3, which has 2 p2p
bridges. We accidentally had less-known scenario: PE#4 was removed
permanently from the system because of permanent failure (e.g.
exceeding the max allowd failure times in last hour), then we detects
EEH errors on PE#3 and tried to recover it. However, eeh_dev instances
for pdev#0/1 were not detached from PE#4, which was still connected to
PE#3. All of that was because of the fact that we rely on count-based
pcibios_release_device(), which isn't reliable enough. When doing
recovery for PE#3, we still apply hotplug on PE#4 and pdev#0/1, which
are not valid any more. Eventually, we run into kernel crash.
The patch fixes above issue from two aspects. For unplug, we simply
skip those permanently removed PE, whose state is (EEH_PE_STATE_ISOLATED
&& !EEH_PE_STATE_RECOVERING) and its frozen count should be greater
than EEH_MAX_ALLOWED_FREEZES. For plug, we marked all permanently
removed EEH devices with EEH_DEV_REMOVED and return 0xFF's on read
its PCI config so that PCI core will omit them.
Signed-off-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-04-24 10:00:19 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Shut down the device drivers for good. We mark
|
|
|
|
* all removed devices correctly to avoid access
|
|
|
|
* the their PCI config any more.
|
|
|
|
*/
|
2014-01-15 14:33:20 +01:00
|
|
|
if (frozen_bus) {
|
2016-03-04 00:53:11 +01:00
|
|
|
if (pe->type & EEH_PE_VF) {
|
|
|
|
eeh_pe_dev_traverse(pe, eeh_rmv_device, NULL);
|
|
|
|
eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
|
|
|
|
} else {
|
|
|
|
eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
|
|
|
|
eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
|
powerpc/eeh: No hotplug on permanently removed dev
The issue was detected in a bit complicated test case where
we have multiple hierarchical PEs shown as following figure:
+-----------------+
| PE#3 p2p#0 |
| p2p#1 |
+-----------------+
|
+-----------------+
| PE#4 pdev#0 |
| pdev#1 |
+-----------------+
PE#4 (have 2 PCI devices) is the child of PE#3, which has 2 p2p
bridges. We accidentally had less-known scenario: PE#4 was removed
permanently from the system because of permanent failure (e.g.
exceeding the max allowd failure times in last hour), then we detects
EEH errors on PE#3 and tried to recover it. However, eeh_dev instances
for pdev#0/1 were not detached from PE#4, which was still connected to
PE#3. All of that was because of the fact that we rely on count-based
pcibios_release_device(), which isn't reliable enough. When doing
recovery for PE#3, we still apply hotplug on PE#4 and pdev#0/1, which
are not valid any more. Eventually, we run into kernel crash.
The patch fixes above issue from two aspects. For unplug, we simply
skip those permanently removed PE, whose state is (EEH_PE_STATE_ISOLATED
&& !EEH_PE_STATE_RECOVERING) and its frozen count should be greater
than EEH_MAX_ALLOWED_FREEZES. For plug, we marked all permanently
removed EEH devices with EEH_DEV_REMOVED and return 0xFF's on read
its PCI config so that PCI core will omit them.
Signed-off-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2014-04-24 10:00:19 +02:00
|
|
|
|
2016-03-04 00:53:11 +01:00
|
|
|
pci_lock_rescan_remove();
|
2016-05-03 07:41:37 +02:00
|
|
|
pci_hp_remove_devices(frozen_bus);
|
2016-03-04 00:53:11 +01:00
|
|
|
pci_unlock_rescan_remove();
|
2017-04-19 09:39:26 +02:00
|
|
|
|
|
|
|
/* The passed PE should no longer be used */
|
|
|
|
return true;
|
2016-03-04 00:53:11 +01:00
|
|
|
}
|
2014-01-15 14:33:20 +01:00
|
|
|
}
|
2017-04-19 09:39:26 +02:00
|
|
|
return false;
|
2005-11-04 01:52:49 +01:00
|
|
|
}
|
2013-06-20 07:21:04 +02:00
|
|
|
|
2017-04-19 09:39:27 +02:00
|
|
|
/**
|
|
|
|
* eeh_handle_special_event - Handle EEH events without a specific failing PE
|
|
|
|
*
|
|
|
|
* Called when an EEH event is detected but can't be narrowed down to a
|
|
|
|
* specific PE. Iterates through possible failures and handles them as
|
|
|
|
* necessary.
|
|
|
|
*/
|
2013-06-20 07:21:04 +02:00
|
|
|
static void eeh_handle_special_event(void)
|
|
|
|
{
|
|
|
|
struct eeh_pe *pe, *phb_pe;
|
|
|
|
struct pci_bus *bus;
|
2014-01-15 06:16:11 +01:00
|
|
|
struct pci_controller *hose;
|
2013-06-20 07:21:04 +02:00
|
|
|
unsigned long flags;
|
2014-01-15 06:16:11 +01:00
|
|
|
int rc;
|
2013-06-20 07:21:04 +02:00
|
|
|
|
|
|
|
|
2014-01-15 06:16:11 +01:00
|
|
|
do {
|
|
|
|
rc = eeh_ops->next_error(&pe);
|
|
|
|
|
|
|
|
switch (rc) {
|
|
|
|
case EEH_NEXT_ERR_DEAD_IOC:
|
|
|
|
/* Mark all PHBs in dead state */
|
|
|
|
eeh_serialize_lock(&flags);
|
|
|
|
|
|
|
|
/* Purge all events */
|
2014-06-04 09:31:52 +02:00
|
|
|
eeh_remove_event(NULL, true);
|
2014-01-15 06:16:11 +01:00
|
|
|
|
|
|
|
list_for_each_entry(hose, &hose_list, list_node) {
|
|
|
|
phb_pe = eeh_phb_pe_get(hose);
|
|
|
|
if (!phb_pe) continue;
|
|
|
|
|
2014-04-24 10:00:07 +02:00
|
|
|
eeh_pe_state_mark(phb_pe, EEH_PE_ISOLATED);
|
2014-01-15 06:16:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
eeh_serialize_unlock(flags);
|
|
|
|
|
|
|
|
break;
|
|
|
|
case EEH_NEXT_ERR_FROZEN_PE:
|
|
|
|
case EEH_NEXT_ERR_FENCED_PHB:
|
|
|
|
case EEH_NEXT_ERR_DEAD_PHB:
|
|
|
|
/* Mark the PE in fenced state */
|
|
|
|
eeh_serialize_lock(&flags);
|
|
|
|
|
|
|
|
/* Purge all events of the PHB */
|
2014-06-04 09:31:52 +02:00
|
|
|
eeh_remove_event(pe, true);
|
2014-01-15 06:16:11 +01:00
|
|
|
|
|
|
|
if (rc == EEH_NEXT_ERR_DEAD_PHB)
|
2014-04-24 10:00:07 +02:00
|
|
|
eeh_pe_state_mark(pe, EEH_PE_ISOLATED);
|
2014-01-15 06:16:11 +01:00
|
|
|
else
|
|
|
|
eeh_pe_state_mark(pe,
|
|
|
|
EEH_PE_ISOLATED | EEH_PE_RECOVERING);
|
|
|
|
|
|
|
|
eeh_serialize_unlock(flags);
|
|
|
|
|
|
|
|
break;
|
|
|
|
case EEH_NEXT_ERR_NONE:
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
pr_warn("%s: Invalid value %d from next_error()\n",
|
|
|
|
__func__, rc);
|
|
|
|
return;
|
2013-06-20 07:21:04 +02:00
|
|
|
}
|
|
|
|
|
2014-01-15 06:16:11 +01:00
|
|
|
/*
|
|
|
|
* For fenced PHB and frozen PE, it's handled as normal
|
|
|
|
* event. We have to remove the affected PHBs for dead
|
|
|
|
* PHB and IOC
|
|
|
|
*/
|
|
|
|
if (rc == EEH_NEXT_ERR_FROZEN_PE ||
|
|
|
|
rc == EEH_NEXT_ERR_FENCED_PHB) {
|
2017-04-19 09:39:26 +02:00
|
|
|
/*
|
|
|
|
* eeh_handle_normal_event() can make the PE stale if it
|
|
|
|
* determines that the PE cannot possibly be recovered.
|
|
|
|
* Don't modify the PE state if that's the case.
|
|
|
|
*/
|
|
|
|
if (eeh_handle_normal_event(pe))
|
|
|
|
continue;
|
|
|
|
|
2014-04-24 10:00:07 +02:00
|
|
|
eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
|
2014-01-15 06:16:11 +01:00
|
|
|
} else {
|
2014-01-28 06:11:26 +01:00
|
|
|
pci_lock_rescan_remove();
|
2014-01-15 06:16:11 +01:00
|
|
|
list_for_each_entry(hose, &hose_list, list_node) {
|
|
|
|
phb_pe = eeh_phb_pe_get(hose);
|
|
|
|
if (!phb_pe ||
|
2014-04-24 10:00:07 +02:00
|
|
|
!(phb_pe->state & EEH_PE_ISOLATED) ||
|
|
|
|
(phb_pe->state & EEH_PE_RECOVERING))
|
2014-01-15 06:16:11 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Notify all devices to be down */
|
2016-02-09 05:50:21 +01:00
|
|
|
eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
|
2016-09-12 06:17:24 +02:00
|
|
|
eeh_pe_dev_traverse(pe,
|
|
|
|
eeh_report_failure, NULL);
|
2014-01-15 06:16:11 +01:00
|
|
|
bus = eeh_pe_bus_get(phb_pe);
|
2016-09-12 06:17:22 +02:00
|
|
|
if (!bus) {
|
|
|
|
pr_err("%s: Cannot find PCI bus for "
|
2016-11-16 04:02:15 +01:00
|
|
|
"PHB#%x-PE#%x\n",
|
2016-09-12 06:17:22 +02:00
|
|
|
__func__,
|
|
|
|
pe->phb->global_number,
|
|
|
|
pe->addr);
|
|
|
|
break;
|
|
|
|
}
|
2016-05-03 07:41:37 +02:00
|
|
|
pci_hp_remove_devices(bus);
|
2014-01-15 06:16:11 +01:00
|
|
|
}
|
2014-01-28 06:11:26 +01:00
|
|
|
pci_unlock_rescan_remove();
|
2013-06-20 07:21:04 +02:00
|
|
|
}
|
2014-01-15 06:16:11 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have detected dead IOC, we needn't proceed
|
|
|
|
* any more since all PHBs would have been removed
|
|
|
|
*/
|
|
|
|
if (rc == EEH_NEXT_ERR_DEAD_IOC)
|
|
|
|
break;
|
|
|
|
} while (rc != EEH_NEXT_ERR_NONE);
|
2013-06-20 07:21:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* eeh_handle_event - Reset a PCI device after hard lockup.
|
|
|
|
* @pe: EEH PE
|
|
|
|
*
|
|
|
|
* While PHB detects address or data parity errors on particular PCI
|
|
|
|
* slot, the associated PE will be frozen. Besides, DMA's occurring
|
|
|
|
* to wild addresses (which usually happen due to bugs in device
|
|
|
|
* drivers or in PCI adapter firmware) can cause EEH error. #SERR,
|
|
|
|
* #PERR or other misc PCI-related errors also can trigger EEH errors.
|
|
|
|
*
|
|
|
|
* Recovery process consists of unplugging the device driver (which
|
|
|
|
* generated hotplug events to userspace), then issuing a PCI #RST to
|
|
|
|
* the device, then reconfiguring the PCI config space for all bridges
|
|
|
|
* & devices under this slot, and then finally restarting the device
|
|
|
|
* drivers (which cause a second set of hotplug events to go out to
|
|
|
|
* userspace).
|
|
|
|
*/
|
|
|
|
void eeh_handle_event(struct eeh_pe *pe)
|
|
|
|
{
|
|
|
|
if (pe)
|
|
|
|
eeh_handle_normal_event(pe);
|
|
|
|
else
|
|
|
|
eeh_handle_special_event();
|
|
|
|
}
|