pci_event.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 *  Copyright IBM Corp. 2012
  4 *
  5 *  Author(s):
  6 *    Jan Glauber <jang@linux.vnet.ibm.com>
  7 */
  8
  9#define pr_fmt(fmt) "zpci: " fmt
 10
 11#include <linux/kernel.h>
 12#include <linux/pci.h>
 13#include <asm/pci_debug.h>
 14#include <asm/pci_dma.h>
 15#include <asm/sclp.h>
 16
 17#include "pci_bus.h"
 18#include "pci_report.h"
 19
 20/* Content Code Description for PCI Function Error */
 21struct zpci_ccdf_err {
 22	u32 reserved1;
 23	u32 fh;				/* function handle */
 24	u32 fid;			/* function id */
 25	u32 ett		:  4;		/* expected table type */
 26	u32 mvn		: 12;		/* MSI vector number */
 27	u32 dmaas	:  8;		/* DMA address space */
 28	u32		:  6;
 29	u32 q		:  1;		/* event qualifier */
 30	u32 rw		:  1;		/* read/write */
 31	u64 faddr;			/* failing address */
 32	u32 reserved3;
 33	u16 reserved4;
 34	u16 pec;			/* PCI event code */
 35} __packed;
 36
 37/* Content Code Description for PCI Function Availability */
 38struct zpci_ccdf_avail {
 39	u32 reserved1;
 40	u32 fh;				/* function handle */
 41	u32 fid;			/* function id */
 42	u32 reserved2;
 43	u32 reserved3;
 44	u32 reserved4;
 45	u32 reserved5;
 46	u16 reserved6;
 47	u16 pec;			/* PCI event code */
 48} __packed;
 49
 50static inline bool ers_result_indicates_abort(pci_ers_result_t ers_res)
 51{
 52	switch (ers_res) {
 53	case PCI_ERS_RESULT_CAN_RECOVER:
 54	case PCI_ERS_RESULT_RECOVERED:
 55	case PCI_ERS_RESULT_NEED_RESET:
 56	case PCI_ERS_RESULT_NONE:
 57		return false;
 58	default:
 59		return true;
 60	}
 61}
 62
 63static bool is_passed_through(struct pci_dev *pdev)
 64{
 65	struct zpci_dev *zdev = to_zpci(pdev);
 66	bool ret;
 67
 68	mutex_lock(&zdev->kzdev_lock);
 69	ret = !!zdev->kzdev;
 70	mutex_unlock(&zdev->kzdev_lock);
 71
 72	return ret;
 73}
 74
 75static bool is_driver_supported(struct pci_driver *driver)
 76{
 77	if (!driver || !driver->err_handler)
 78		return false;
 79	if (!driver->err_handler->error_detected)
 80		return false;
 81	return true;
 82}
 83
 84static pci_ers_result_t zpci_event_notify_error_detected(struct pci_dev *pdev,
 85							 struct pci_driver *driver)
 86{
 87	pci_ers_result_t ers_res = PCI_ERS_RESULT_DISCONNECT;
 88
 89	ers_res = driver->err_handler->error_detected(pdev,  pdev->error_state);
 90	pci_uevent_ers(pdev, ers_res);
 91	if (ers_result_indicates_abort(ers_res))
 92		pr_info("%s: Automatic recovery failed after initial reporting\n", pci_name(pdev));
 93	else if (ers_res == PCI_ERS_RESULT_NEED_RESET)
 94		pr_debug("%s: Driver needs reset to recover\n", pci_name(pdev));
 95
 96	return ers_res;
 97}
 98
 99static pci_ers_result_t zpci_event_do_error_state_clear(struct pci_dev *pdev,
100							struct pci_driver *driver)
101{
102	pci_ers_result_t ers_res = PCI_ERS_RESULT_DISCONNECT;
103	struct zpci_dev *zdev = to_zpci(pdev);
104	int rc;
105
106	/* The underlying device may have been disabled by the event */
107	if (!zdev_enabled(zdev))
108		return PCI_ERS_RESULT_NEED_RESET;
109
110	pr_info("%s: Unblocking device access for examination\n", pci_name(pdev));
111	rc = zpci_reset_load_store_blocked(zdev);
112	if (rc) {
113		pr_err("%s: Unblocking device access failed\n", pci_name(pdev));
114		/* Let's try a full reset instead */
115		return PCI_ERS_RESULT_NEED_RESET;
116	}
117
118	if (driver->err_handler->mmio_enabled)
119		ers_res = driver->err_handler->mmio_enabled(pdev);
120	else
121		ers_res = PCI_ERS_RESULT_NONE;
122
123	if (ers_result_indicates_abort(ers_res)) {
124		pr_info("%s: Automatic recovery failed after MMIO re-enable\n",
125			pci_name(pdev));
126		return ers_res;
127	} else if (ers_res == PCI_ERS_RESULT_NEED_RESET) {
128		pr_debug("%s: Driver needs reset to recover\n", pci_name(pdev));
129		return ers_res;
130	}
131
132	pr_debug("%s: Unblocking DMA\n", pci_name(pdev));
133	rc = zpci_clear_error_state(zdev);
134	if (!rc) {
135		pdev->error_state = pci_channel_io_normal;
136	} else {
137		pr_err("%s: Unblocking DMA failed\n", pci_name(pdev));
138		/* Let's try a full reset instead */
139		return PCI_ERS_RESULT_NEED_RESET;
140	}
141
142	return ers_res;
143}
144
145static pci_ers_result_t zpci_event_do_reset(struct pci_dev *pdev,
146					    struct pci_driver *driver)
147{
148	pci_ers_result_t ers_res = PCI_ERS_RESULT_DISCONNECT;
149
150	pr_info("%s: Initiating reset\n", pci_name(pdev));
151	if (zpci_hot_reset_device(to_zpci(pdev))) {
152		pr_err("%s: The reset request failed\n", pci_name(pdev));
153		return ers_res;
154	}
155	pdev->error_state = pci_channel_io_normal;
156
157	if (driver->err_handler->slot_reset)
158		ers_res = driver->err_handler->slot_reset(pdev);
159	else
160		ers_res = PCI_ERS_RESULT_NONE;
161
162	if (ers_result_indicates_abort(ers_res)) {
163		pr_info("%s: Automatic recovery failed after slot reset\n", pci_name(pdev));
164		return ers_res;
165	}
166
167	return ers_res;
168}
169
170/* zpci_event_attempt_error_recovery - Try to recover the given PCI function
171 * @pdev: PCI function to recover currently in the error state
172 *
173 * We follow the scheme outlined in Documentation/PCI/pci-error-recovery.rst.
174 * With the simplification that recovery always happens per function
175 * and the platform determines which functions are affected for
176 * multi-function devices.
177 */
178static pci_ers_result_t zpci_event_attempt_error_recovery(struct pci_dev *pdev)
179{
180	pci_ers_result_t ers_res = PCI_ERS_RESULT_DISCONNECT;
181	struct zpci_dev *zdev = to_zpci(pdev);
182	char *status_str = "success";
183	struct pci_driver *driver;
184
185	/*
186	 * Ensure that the PCI function is not removed concurrently, no driver
187	 * is unbound or probed and that userspace can't access its
188	 * configuration space while we perform recovery.
189	 */
190	device_lock(&pdev->dev);
191	if (pdev->error_state == pci_channel_io_perm_failure) {
192		ers_res = PCI_ERS_RESULT_DISCONNECT;
193		goto out_unlock;
194	}
195	pdev->error_state = pci_channel_io_frozen;
196
197	if (is_passed_through(pdev)) {
198		pr_info("%s: Cannot be recovered in the host because it is a pass-through device\n",
199			pci_name(pdev));
200		status_str = "failed (pass-through)";
201		goto out_unlock;
202	}
203
204	driver = to_pci_driver(pdev->dev.driver);
205	if (!is_driver_supported(driver)) {
206		if (!driver) {
207			pr_info("%s: Cannot be recovered because no driver is bound to the device\n",
208				pci_name(pdev));
209			status_str = "failed (no driver)";
210		} else {
211			pr_info("%s: The %s driver bound to the device does not support error recovery\n",
212				pci_name(pdev),
213				driver->name);
214			status_str = "failed (no driver support)";
215		}
216		goto out_unlock;
217	}
218
219	ers_res = zpci_event_notify_error_detected(pdev, driver);
220	if (ers_result_indicates_abort(ers_res)) {
221		status_str = "failed (abort on detection)";
222		goto out_unlock;
223	}
224
225	if (ers_res != PCI_ERS_RESULT_NEED_RESET) {
226		ers_res = zpci_event_do_error_state_clear(pdev, driver);
227		if (ers_result_indicates_abort(ers_res)) {
228			status_str = "failed (abort on MMIO enable)";
229			goto out_unlock;
230		}
231	}
232
233	if (ers_res == PCI_ERS_RESULT_NEED_RESET)
234		ers_res = zpci_event_do_reset(pdev, driver);
235
236	/*
237	 * ers_res can be PCI_ERS_RESULT_NONE either because the driver
238	 * decided to return it, indicating that it abstains from voting
239	 * on how to recover, or because it didn't implement the callback.
240	 * Both cases assume, that if there is nothing else causing a
241	 * disconnect, we recovered successfully.
242	 */
243	if (ers_res == PCI_ERS_RESULT_NONE)
244		ers_res = PCI_ERS_RESULT_RECOVERED;
245
246	if (ers_res != PCI_ERS_RESULT_RECOVERED) {
247		pci_uevent_ers(pdev, PCI_ERS_RESULT_DISCONNECT);
248		pr_err("%s: Automatic recovery failed; operator intervention is required\n",
249		       pci_name(pdev));
250		status_str = "failed (driver can't recover)";
251		goto out_unlock;
252	}
253
254	pr_info("%s: The device is ready to resume operations\n", pci_name(pdev));
255	if (driver->err_handler->resume)
256		driver->err_handler->resume(pdev);
257	pci_uevent_ers(pdev, PCI_ERS_RESULT_RECOVERED);
258out_unlock:
259	device_unlock(&pdev->dev);
260	zpci_report_status(zdev, "recovery", status_str);
261
262	return ers_res;
263}
264
265/* zpci_event_io_failure - Report PCI channel failure state to driver
266 * @pdev: PCI function for which to report
267 * @es: PCI channel failure state to report
268 */
269static void zpci_event_io_failure(struct pci_dev *pdev, pci_channel_state_t es)
270{
271	struct pci_driver *driver;
272
273	pci_dev_lock(pdev);
274	pdev->error_state = es;
275	/**
276	 * While vfio-pci's error_detected callback notifies user-space QEMU
277	 * reacts to this by freezing the guest. In an s390 environment PCI
278	 * errors are rarely fatal so this is overkill. Instead in the future
279	 * we will inject the error event and let the guest recover the device
280	 * itself.
281	 */
282	if (is_passed_through(pdev))
283		goto out;
284	driver = to_pci_driver(pdev->dev.driver);
285	if (driver && driver->err_handler && driver->err_handler->error_detected)
286		driver->err_handler->error_detected(pdev, pdev->error_state);
287out:
288	pci_dev_unlock(pdev);
289}
290
291static void __zpci_event_error(struct zpci_ccdf_err *ccdf)
292{
293	struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
294	struct pci_dev *pdev = NULL;
295	pci_ers_result_t ers_res;
296	u32 fh = 0;
297	int rc;
298
299	zpci_dbg(3, "err fid:%x, fh:%x, pec:%x\n",
300		 ccdf->fid, ccdf->fh, ccdf->pec);
301	zpci_err("error CCDF:\n");
302	zpci_err_hex(ccdf, sizeof(*ccdf));
303
304	if (zdev) {
305		mutex_lock(&zdev->state_lock);
306		rc = clp_refresh_fh(zdev->fid, &fh);
307		if (rc)
308			goto no_pdev;
309		if (!fh || ccdf->fh != fh) {
310			/* Ignore events with stale handles */
311			zpci_dbg(3, "err fid:%x, fh:%x (stale %x)\n",
312				 ccdf->fid, fh, ccdf->fh);
313			goto no_pdev;
314		}
315		zpci_update_fh(zdev, ccdf->fh);
316		if (zdev->zbus->bus)
317			pdev = pci_get_slot(zdev->zbus->bus, zdev->devfn);
318	}
319
320	pr_err("%s: Event 0x%x reports an error for PCI function 0x%x\n",
321	       pdev ? pci_name(pdev) : "n/a", ccdf->pec, ccdf->fid);
322
323	if (!pdev)
324		goto no_pdev;
325
326	switch (ccdf->pec) {
327	case 0x002a: /* Error event concerns FMB */
328	case 0x002b:
329	case 0x002c:
330		break;
331	case 0x0040: /* Service Action or Error Recovery Failed */
332	case 0x003b:
333		zpci_event_io_failure(pdev, pci_channel_io_perm_failure);
334		break;
335	default: /* PCI function left in the error state attempt to recover */
336		ers_res = zpci_event_attempt_error_recovery(pdev);
337		if (ers_res != PCI_ERS_RESULT_RECOVERED)
338			zpci_event_io_failure(pdev, pci_channel_io_perm_failure);
339		break;
340	}
341	pci_dev_put(pdev);
342no_pdev:
343	if (zdev)
344		mutex_unlock(&zdev->state_lock);
345	zpci_zdev_put(zdev);
346}
347
348void zpci_event_error(void *data)
349{
350	if (zpci_is_enabled())
351		__zpci_event_error(data);
352}
353
354static void zpci_event_hard_deconfigured(struct zpci_dev *zdev, u32 fh)
355{
356	zpci_update_fh(zdev, fh);
357	/* Give the driver a hint that the function is
358	 * already unusable.
359	 */
360	zpci_bus_remove_device(zdev, true);
361	/* Even though the device is already gone we still
362	 * need to free zPCI resources as part of the disable.
363	 */
364	if (zdev_enabled(zdev))
365		zpci_disable_device(zdev);
366	zdev->state = ZPCI_FN_STATE_STANDBY;
367}
368
369static void zpci_event_reappear(struct zpci_dev *zdev)
370{
371	lockdep_assert_held(&zdev->state_lock);
372	/*
373	 * The zdev is in the reserved state. This means that it was presumed to
374	 * go away but there are still undropped references. Now, the platform
375	 * announced its availability again. Bring back the lingering zdev
376	 * to standby. This is safe because we hold a temporary reference
377	 * now so that it won't go away. Account for the re-appearance of the
378	 * underlying device by incrementing the reference count.
379	 */
380	zdev->state = ZPCI_FN_STATE_STANDBY;
381	zpci_zdev_get(zdev);
382	zpci_dbg(1, "rea fid:%x, fh:%x\n", zdev->fid, zdev->fh);
383}
384
385static void __zpci_event_availability(struct zpci_ccdf_avail *ccdf)
386{
387	struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
388	bool existing_zdev = !!zdev;
389	enum zpci_state state;
390
391	zpci_dbg(3, "avl fid:%x, fh:%x, pec:%x\n",
392		 ccdf->fid, ccdf->fh, ccdf->pec);
393
394	if (existing_zdev)
395		mutex_lock(&zdev->state_lock);
396
397	switch (ccdf->pec) {
398	case 0x0301: /* Reserved|Standby -> Configured */
399		if (!zdev) {
400			zdev = zpci_create_device(ccdf->fid, ccdf->fh, ZPCI_FN_STATE_CONFIGURED);
401			if (IS_ERR(zdev))
402				break;
403			if (zpci_add_device(zdev)) {
404				kfree(zdev);
405				break;
406			}
407		} else {
408			if (zdev->state == ZPCI_FN_STATE_RESERVED)
409				zpci_event_reappear(zdev);
410			/* the configuration request may be stale */
411			else if (zdev->state != ZPCI_FN_STATE_STANDBY)
412				break;
413			zdev->state = ZPCI_FN_STATE_CONFIGURED;
414		}
415		zpci_scan_configured_device(zdev, ccdf->fh);
416		break;
417	case 0x0302: /* Reserved -> Standby */
418		if (!zdev) {
419			zdev = zpci_create_device(ccdf->fid, ccdf->fh, ZPCI_FN_STATE_STANDBY);
420			if (IS_ERR(zdev))
421				break;
422			if (zpci_add_device(zdev)) {
423				kfree(zdev);
424				break;
425			}
426		} else {
427			if (zdev->state == ZPCI_FN_STATE_RESERVED)
428				zpci_event_reappear(zdev);
429			zpci_update_fh(zdev, ccdf->fh);
430		}
431		break;
432	case 0x0303: /* Deconfiguration requested */
433		if (zdev) {
434			/* The event may have been queued before we configured
435			 * the device.
436			 */
437			if (zdev->state != ZPCI_FN_STATE_CONFIGURED)
438				break;
439			zpci_update_fh(zdev, ccdf->fh);
440			zpci_deconfigure_device(zdev);
441		}
442		break;
443	case 0x0304: /* Configured -> Standby|Reserved */
444		if (zdev) {
445			/* The event may have been queued before we configured
446			 * the device.:
447			 */
448			if (zdev->state == ZPCI_FN_STATE_CONFIGURED)
449				zpci_event_hard_deconfigured(zdev, ccdf->fh);
450			/* The 0x0304 event may immediately reserve the device */
451			if (!clp_get_state(zdev->fid, &state) &&
452			    state == ZPCI_FN_STATE_RESERVED) {
453				zpci_device_reserved(zdev);
454			}
455		}
456		break;
457	case 0x0306: /* 0x308 or 0x302 for multiple devices */
458		zpci_remove_reserved_devices();
459		zpci_scan_devices();
460		break;
461	case 0x0308: /* Standby -> Reserved */
462		if (!zdev)
463			break;
464		zpci_device_reserved(zdev);
465		break;
466	default:
467		break;
468	}
469	if (existing_zdev) {
470		mutex_unlock(&zdev->state_lock);
471		zpci_zdev_put(zdev);
472	}
473}
474
475void zpci_event_availability(void *data)
476{
477	if (zpci_is_enabled())
478		__zpci_event_availability(data);
479}