Commit | Line | Data |
---|---|---|
1a59d1b8 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
172ca926 | 2 | /* |
172ca926 LV |
3 | * |
4 | * Copyright (c) 2005 Linas Vepstas <linas@linas.org> | |
5 | */ | |
6 | ||
ac325acd | 7 | #include <linux/delay.h> |
172ca926 | 8 | #include <linux/list.h> |
62fe91bb | 9 | #include <linux/sched.h> |
c8608558 | 10 | #include <linux/semaphore.h> |
172ca926 | 11 | #include <linux/pci.h> |
5a0e3ad6 | 12 | #include <linux/slab.h> |
ecf89e58 | 13 | #include <linux/kthread.h> |
172ca926 | 14 | #include <asm/eeh_event.h> |
77bd7415 | 15 | #include <asm/ppc-pci.h> |
172ca926 LV |
16 | |
17 | /** Overview: | |
18 | * EEH error states may be detected within exception handlers; | |
19 | * however, the recovery processing needs to occur asynchronously | |
20 | * in a normal kernel context and not an interrupt context. | |
21 | * This pair of routines creates an event and queues it onto a | |
22 | * work-queue, where a worker thread can drive recovery. | |
23 | */ | |
24 | ||
34af946a | 25 | static DEFINE_SPINLOCK(eeh_eventlist_lock); |
2fea82db | 26 | static DECLARE_COMPLETION(eeh_eventlist_event); |
635218c7 | 27 | static LIST_HEAD(eeh_eventlist); |
8c33fd11 | 28 | |
172ca926 | 29 | /** |
29f8bf1b | 30 | * eeh_event_handler - Dispatch EEH events. |
172ca926 | 31 | * @dummy - unused |
8c33fd11 LV |
32 | * |
33 | * The detection of a frozen slot can occur inside an interrupt, | |
34 | * where it can be hard to do anything about it. The goal of this | |
35 | * routine is to pull these detection events out of the context | |
36 | * of the interrupt handler, and re-dispatch them for processing | |
37 | * at a later time in a normal context. | |
172ca926 LV |
38 | */ |
39 | static int eeh_event_handler(void * dummy) | |
40 | { | |
41 | unsigned long flags; | |
40a7cd92 | 42 | struct eeh_event *event; |
172ca926 | 43 | |
c8608558 | 44 | while (!kthread_should_stop()) { |
2fea82db | 45 | if (wait_for_completion_interruptible(&eeh_eventlist_event)) |
5459ae14 | 46 | break; |
c8608558 GS |
47 | |
48 | /* Fetch EEH event from the queue */ | |
49 | spin_lock_irqsave(&eeh_eventlist_lock, flags); | |
50 | event = NULL; | |
51 | if (!list_empty(&eeh_eventlist)) { | |
52 | event = list_entry(eeh_eventlist.next, | |
53 | struct eeh_event, list); | |
54 | list_del(&event->list); | |
55 | } | |
56 | spin_unlock_irqrestore(&eeh_eventlist_lock, flags); | |
57 | if (!event) | |
58 | continue; | |
59 | ||
60 | /* We might have event without binding PE */ | |
25baf3d8 OH |
61 | if (event->pe) |
62 | eeh_handle_normal_event(event->pe); | |
63 | else | |
68701780 | 64 | eeh_handle_special_event(); |
c8608558 GS |
65 | |
66 | kfree(event); | |
172ca926 LV |
67 | } |
68 | ||
69 | return 0; | |
70 | } | |
71 | ||
72 | /** | |
c8608558 | 73 | * eeh_event_init - Start kernel thread to handle EEH events |
29f8bf1b GS |
74 | * |
75 | * This routine is called to start the kernel thread for processing | |
76 | * EEH event. | |
172ca926 | 77 | */ |
c8608558 | 78 | int eeh_event_init(void) |
172ca926 | 79 | { |
c8608558 GS |
80 | struct task_struct *t; |
81 | int ret = 0; | |
82 | ||
c8608558 GS |
83 | t = kthread_run(eeh_event_handler, NULL, "eehd"); |
84 | if (IS_ERR(t)) { | |
85 | ret = PTR_ERR(t); | |
86 | pr_err("%s: Failed to start EEH daemon (%d)\n", | |
87 | __func__, ret); | |
88 | return ret; | |
89 | } | |
90 | ||
91 | return 0; | |
172ca926 LV |
92 | } |
93 | ||
94 | /** | |
29f8bf1b | 95 | * eeh_send_failure_event - Generate a PCI error event |
c533b46c | 96 | * @pe: EEH PE |
172ca926 LV |
97 | * |
98 | * This routine can be called within an interrupt context; | |
99 | * the actual event will be delivered in a normal context | |
100 | * (from a workqueue). | |
101 | */ | |
954bd994 | 102 | int __eeh_send_failure_event(struct eeh_pe *pe) |
172ca926 LV |
103 | { |
104 | unsigned long flags; | |
105 | struct eeh_event *event; | |
172ca926 | 106 | |
c533b46c GS |
107 | event = kzalloc(sizeof(*event), GFP_ATOMIC); |
108 | if (!event) { | |
109 | pr_err("EEH: out of memory, event not handled\n"); | |
110 | return -ENOMEM; | |
111 | } | |
112 | event->pe = pe; | |
172ca926 | 113 | |
799abe28 OH |
114 | /* |
115 | * Mark the PE as recovering before inserting it in the queue. | |
116 | * This prevents the PE from being free()ed by a hotplug driver | |
117 | * while the PE is sitting in the event queue. | |
118 | */ | |
25baf3d8 | 119 | if (pe) { |
1b7f3b6c | 120 | #ifdef CONFIG_STACKTRACE |
25baf3d8 OH |
121 | /* |
122 | * Save the current stack trace so we can dump it from the | |
123 | * event handler thread. | |
124 | */ | |
125 | pe->trace_entries = stack_trace_save(pe->stack_trace, | |
126 | ARRAY_SIZE(pe->stack_trace), 0); | |
1b7f3b6c | 127 | #endif /* CONFIG_STACKTRACE */ |
25baf3d8 | 128 | |
799abe28 | 129 | eeh_pe_state_mark(pe, EEH_PE_RECOVERING); |
25baf3d8 | 130 | } |
799abe28 | 131 | |
172ca926 LV |
132 | /* We may or may not be called in an interrupt context */ |
133 | spin_lock_irqsave(&eeh_eventlist_lock, flags); | |
134 | list_add(&event->list, &eeh_eventlist); | |
135 | spin_unlock_irqrestore(&eeh_eventlist_lock, flags); | |
136 | ||
c8608558 | 137 | /* For EEH deamon to knick in */ |
2fea82db | 138 | complete(&eeh_eventlist_event); |
172ca926 LV |
139 | |
140 | return 0; | |
141 | } | |
99866595 | 142 | |
954bd994 OH |
143 | int eeh_send_failure_event(struct eeh_pe *pe) |
144 | { | |
145 | /* | |
1fd02f66 | 146 | * If we've manually suppressed recovery events via debugfs |
954bd994 OH |
147 | * then just drop it on the floor. |
148 | */ | |
149 | if (eeh_debugfs_no_recover) { | |
150 | pr_err("EEH: Event dropped due to no_recover setting\n"); | |
151 | return 0; | |
152 | } | |
153 | ||
154 | return __eeh_send_failure_event(pe); | |
155 | } | |
156 | ||
99866595 GS |
157 | /** |
158 | * eeh_remove_event - Remove EEH event from the queue | |
159 | * @pe: Event binding to the PE | |
5c7a35e3 | 160 | * @force: Event will be removed unconditionally |
99866595 GS |
161 | * |
162 | * On PowerNV platform, we might have subsequent coming events | |
163 | * is part of the former one. For that case, those subsequent | |
164 | * coming events are totally duplicated and unnecessary, thus | |
165 | * they should be removed. | |
166 | */ | |
5c7a35e3 | 167 | void eeh_remove_event(struct eeh_pe *pe, bool force) |
99866595 GS |
168 | { |
169 | unsigned long flags; | |
170 | struct eeh_event *event, *tmp; | |
171 | ||
5c7a35e3 GS |
172 | /* |
173 | * If we have NULL PE passed in, we have dead IOC | |
174 | * or we're sure we can report all existing errors | |
175 | * by the caller. | |
176 | * | |
177 | * With "force", the event with associated PE that | |
178 | * have been isolated, the event won't be removed | |
179 | * to avoid event lost. | |
180 | */ | |
99866595 GS |
181 | spin_lock_irqsave(&eeh_eventlist_lock, flags); |
182 | list_for_each_entry_safe(event, tmp, &eeh_eventlist, list) { | |
5c7a35e3 GS |
183 | if (!force && event->pe && |
184 | (event->pe->state & EEH_PE_ISOLATED)) | |
185 | continue; | |
186 | ||
99866595 GS |
187 | if (!pe) { |
188 | list_del(&event->list); | |
189 | kfree(event); | |
190 | } else if (pe->type & EEH_PE_PHB) { | |
191 | if (event->pe && event->pe->phb == pe->phb) { | |
192 | list_del(&event->list); | |
193 | kfree(event); | |
194 | } | |
195 | } else if (event->pe == pe) { | |
196 | list_del(&event->list); | |
197 | kfree(event); | |
198 | } | |
199 | } | |
200 | spin_unlock_irqrestore(&eeh_eventlist_lock, flags); | |
201 | } |