blob: a6e3c8dc2be4e9a42d4df8c1270b5e3e5ef25188 [file] [log] [blame]
Huang Yingd334a492010-05-18 14:35:20 +08001/*
2 * APEI Generic Hardware Error Source support
3 *
4 * Generic Hardware Error Source provides a way to report platform
5 * hardware errors (such as that from chipset). It works in so called
6 * "Firmware First" mode, that is, hardware errors are reported to
7 * firmware firstly, then reported to Linux by firmware. This way,
8 * some non-standard hardware error registers or non-standard hardware
9 * link can be checked by firmware to produce more hardware error
10 * information for Linux.
11 *
12 * For more information about Generic Hardware Error Source, please
13 * refer to ACPI Specification version 4.0, section 17.3.2.6
14 *
Huang Ying67eb2e92011-07-13 13:14:25 +080015 * Copyright 2010,2011 Intel Corp.
Huang Yingd334a492010-05-18 14:35:20 +080016 * Author: Huang Ying <ying.huang@intel.com>
17 *
18 * This program is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU General Public License version
20 * 2 as published by the Free Software Foundation;
21 *
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
Huang Yingd334a492010-05-18 14:35:20 +080026 */
27
28#include <linux/kernel.h>
Paul Gortmaker020bf062016-02-15 00:27:50 -050029#include <linux/moduleparam.h>
Huang Yingd334a492010-05-18 14:35:20 +080030#include <linux/init.h>
31#include <linux/acpi.h>
32#include <linux/io.h>
33#include <linux/interrupt.h>
Huang Ying81e88fd2011-01-12 14:44:55 +080034#include <linux/timer.h>
Huang Yingd334a492010-05-18 14:35:20 +080035#include <linux/cper.h>
36#include <linux/kdebug.h>
Huang Ying7ad6e942010-08-02 15:48:24 +080037#include <linux/platform_device.h>
38#include <linux/mutex.h>
Huang Ying32c361f2010-12-07 10:22:31 +080039#include <linux/ratelimit.h>
Huang Ying81e88fd2011-01-12 14:44:55 +080040#include <linux/vmalloc.h>
Huang Ying67eb2e92011-07-13 13:14:25 +080041#include <linux/irq_work.h>
42#include <linux/llist.h>
43#include <linux/genalloc.h>
Huang Yinga654e5e2011-12-08 11:25:41 +080044#include <linux/pci.h>
45#include <linux/aer.h>
Tomasz Nowicki44a69f62014-07-22 11:20:12 +020046#include <linux/nmi.h>
Mauro Carvalho Chehab40e06412013-02-15 05:41:22 -030047
48#include <acpi/ghes.h>
Tomasz Nowicki9dae3d02014-07-22 11:20:11 +020049#include <acpi/apei.h>
Huang Ying81e88fd2011-01-12 14:44:55 +080050#include <asm/tlbflush.h>
Huang Yingd334a492010-05-18 14:35:20 +080051
52#include "apei-internal.h"
53
54#define GHES_PFX "GHES: "
55
56#define GHES_ESTATUS_MAX_SIZE 65536
Huang Ying67eb2e92011-07-13 13:14:25 +080057#define GHES_ESOURCE_PREALLOC_MAX_SIZE 65536
58
59#define GHES_ESTATUS_POOL_MIN_ALLOC_ORDER 3
60
Huang Ying152cef42011-07-13 13:14:26 +080061/* This is just an estimation for memory pool allocation */
62#define GHES_ESTATUS_CACHE_AVG_SIZE 512
63
64#define GHES_ESTATUS_CACHES_SIZE 4
65
Len Brown70cb6e12011-08-02 18:00:21 -040066#define GHES_ESTATUS_IN_CACHE_MAX_NSEC 10000000000ULL
Huang Ying152cef42011-07-13 13:14:26 +080067/* Prevent too many caches are allocated because of RCU */
68#define GHES_ESTATUS_CACHE_ALLOCED_MAX (GHES_ESTATUS_CACHES_SIZE * 3 / 2)
69
70#define GHES_ESTATUS_CACHE_LEN(estatus_len) \
71 (sizeof(struct ghes_estatus_cache) + (estatus_len))
72#define GHES_ESTATUS_FROM_CACHE(estatus_cache) \
Lv Zheng0a00fd52014-06-03 16:32:53 +080073 ((struct acpi_hest_generic_status *) \
Huang Ying152cef42011-07-13 13:14:26 +080074 ((struct ghes_estatus_cache *)(estatus_cache) + 1))
75
Huang Ying67eb2e92011-07-13 13:14:25 +080076#define GHES_ESTATUS_NODE_LEN(estatus_len) \
77 (sizeof(struct ghes_estatus_node) + (estatus_len))
Chen, Gong88f074f2013-10-18 14:28:59 -070078#define GHES_ESTATUS_FROM_NODE(estatus_node) \
Lv Zheng0a00fd52014-06-03 16:32:53 +080079 ((struct acpi_hest_generic_status *) \
Huang Ying67eb2e92011-07-13 13:14:25 +080080 ((struct ghes_estatus_node *)(estatus_node) + 1))
Huang Yingd334a492010-05-18 14:35:20 +080081
Paul Gortmaker020bf062016-02-15 00:27:50 -050082/*
83 * This driver isn't really modular, however for the time being,
84 * continuing to use module_param is the easiest way to remain
85 * compatible with existing boot arg use cases.
86 */
Rusty Russell90ab5ee2012-01-13 09:32:20 +103087bool ghes_disable;
Huang Yingb6a95012011-07-13 13:14:19 +080088module_param_named(disable, ghes_disable, bool, 0);
89
Huang Yingd334a492010-05-18 14:35:20 +080090/*
Huang Ying81e88fd2011-01-12 14:44:55 +080091 * All error sources notified with SCI shares one notifier function,
92 * so they need to be linked and checked one by one. This is applied
93 * to NMI too.
Huang Yingd334a492010-05-18 14:35:20 +080094 *
Huang Ying81e88fd2011-01-12 14:44:55 +080095 * RCU is used for these lists, so ghes_list_mutex is only used for
96 * list changing, not for traversing.
Huang Yingd334a492010-05-18 14:35:20 +080097 */
98static LIST_HEAD(ghes_sci);
Huang Ying7ad6e942010-08-02 15:48:24 +080099static DEFINE_MUTEX(ghes_list_mutex);
Huang Yingd334a492010-05-18 14:35:20 +0800100
Huang Ying81e88fd2011-01-12 14:44:55 +0800101/*
Huang Ying81e88fd2011-01-12 14:44:55 +0800102 * Because the memory area used to transfer hardware error information
103 * from BIOS to Linux can be determined only in NMI, IRQ or timer
104 * handler, but general ioremap can not be used in atomic context, so
105 * a special version of atomic ioremap is implemented for that.
106 */
107
108/*
Tomasz Nowicki594c7252014-07-22 11:20:13 +0200109 * Two virtual pages are used, one for IRQ/PROCESS context, the other for
110 * NMI context (optionally).
Huang Ying81e88fd2011-01-12 14:44:55 +0800111 */
Tomasz Nowicki594c7252014-07-22 11:20:13 +0200112#ifdef CONFIG_HAVE_ACPI_APEI_NMI
113#define GHES_IOREMAP_PAGES 2
114#else
115#define GHES_IOREMAP_PAGES 1
116#endif
117#define GHES_IOREMAP_IRQ_PAGE(base) (base)
118#define GHES_IOREMAP_NMI_PAGE(base) ((base) + PAGE_SIZE)
Huang Ying81e88fd2011-01-12 14:44:55 +0800119
120/* virtual memory area for atomic ioremap */
121static struct vm_struct *ghes_ioremap_area;
122/*
123 * These 2 spinlock is used to prevent atomic ioremap virtual memory
124 * area from being mapped simultaneously.
125 */
126static DEFINE_RAW_SPINLOCK(ghes_ioremap_lock_nmi);
127static DEFINE_SPINLOCK(ghes_ioremap_lock_irq);
128
Huang Ying67eb2e92011-07-13 13:14:25 +0800129static struct gen_pool *ghes_estatus_pool;
130static unsigned long ghes_estatus_pool_size_request;
Huang Ying67eb2e92011-07-13 13:14:25 +0800131
Borislav Petkov8f7c31f2014-09-29 13:33:17 +0200132static struct ghes_estatus_cache *ghes_estatus_caches[GHES_ESTATUS_CACHES_SIZE];
Huang Ying152cef42011-07-13 13:14:26 +0800133static atomic_t ghes_estatus_cache_alloced;
134
Huang Ying81e88fd2011-01-12 14:44:55 +0800135static int ghes_ioremap_init(void)
136{
137 ghes_ioremap_area = __get_vm_area(PAGE_SIZE * GHES_IOREMAP_PAGES,
138 VM_IOREMAP, VMALLOC_START, VMALLOC_END);
139 if (!ghes_ioremap_area) {
140 pr_err(GHES_PFX "Failed to allocate virtual memory area for atomic ioremap.\n");
141 return -ENOMEM;
142 }
143
144 return 0;
145}
146
147static void ghes_ioremap_exit(void)
148{
149 free_vm_area(ghes_ioremap_area);
150}
151
152static void __iomem *ghes_ioremap_pfn_nmi(u64 pfn)
153{
154 unsigned long vaddr;
155
156 vaddr = (unsigned long)GHES_IOREMAP_NMI_PAGE(ghes_ioremap_area->addr);
157 ioremap_page_range(vaddr, vaddr + PAGE_SIZE,
158 pfn << PAGE_SHIFT, PAGE_KERNEL);
159
160 return (void __iomem *)vaddr;
161}
162
163static void __iomem *ghes_ioremap_pfn_irq(u64 pfn)
164{
Jonathan (Zhixiong) Zhang8ece2492015-09-04 14:11:42 +0100165 unsigned long vaddr, paddr;
166 pgprot_t prot;
Huang Ying81e88fd2011-01-12 14:44:55 +0800167
168 vaddr = (unsigned long)GHES_IOREMAP_IRQ_PAGE(ghes_ioremap_area->addr);
Jonathan (Zhixiong) Zhang8ece2492015-09-04 14:11:42 +0100169
170 paddr = pfn << PAGE_SHIFT;
171 prot = arch_apei_get_mem_attribute(paddr);
172
173 ioremap_page_range(vaddr, vaddr + PAGE_SIZE, paddr, prot);
Huang Ying81e88fd2011-01-12 14:44:55 +0800174
175 return (void __iomem *)vaddr;
176}
177
178static void ghes_iounmap_nmi(void __iomem *vaddr_ptr)
179{
180 unsigned long vaddr = (unsigned long __force)vaddr_ptr;
181 void *base = ghes_ioremap_area->addr;
182
183 BUG_ON(vaddr != (unsigned long)GHES_IOREMAP_NMI_PAGE(base));
184 unmap_kernel_range_noflush(vaddr, PAGE_SIZE);
Tomasz Nowicki594c7252014-07-22 11:20:13 +0200185 arch_apei_flush_tlb_one(vaddr);
Huang Ying81e88fd2011-01-12 14:44:55 +0800186}
187
188static void ghes_iounmap_irq(void __iomem *vaddr_ptr)
189{
190 unsigned long vaddr = (unsigned long __force)vaddr_ptr;
191 void *base = ghes_ioremap_area->addr;
192
193 BUG_ON(vaddr != (unsigned long)GHES_IOREMAP_IRQ_PAGE(base));
194 unmap_kernel_range_noflush(vaddr, PAGE_SIZE);
Tomasz Nowicki594c7252014-07-22 11:20:13 +0200195 arch_apei_flush_tlb_one(vaddr);
Huang Ying81e88fd2011-01-12 14:44:55 +0800196}
197
Huang Ying67eb2e92011-07-13 13:14:25 +0800198static int ghes_estatus_pool_init(void)
199{
200 ghes_estatus_pool = gen_pool_create(GHES_ESTATUS_POOL_MIN_ALLOC_ORDER, -1);
201 if (!ghes_estatus_pool)
202 return -ENOMEM;
203 return 0;
204}
205
James Morse54a87fd2019-01-29 18:48:39 +0000206static void ghes_estatus_pool_free_chunk(struct gen_pool *pool,
Huang Ying67eb2e92011-07-13 13:14:25 +0800207 struct gen_pool_chunk *chunk,
208 void *data)
209{
James Morse54a87fd2019-01-29 18:48:39 +0000210 vfree((void *)chunk->start_addr);
Huang Ying67eb2e92011-07-13 13:14:25 +0800211}
212
213static void ghes_estatus_pool_exit(void)
214{
215 gen_pool_for_each_chunk(ghes_estatus_pool,
James Morse54a87fd2019-01-29 18:48:39 +0000216 ghes_estatus_pool_free_chunk, NULL);
Huang Ying67eb2e92011-07-13 13:14:25 +0800217 gen_pool_destroy(ghes_estatus_pool);
218}
219
220static int ghes_estatus_pool_expand(unsigned long len)
221{
James Morse54a87fd2019-01-29 18:48:39 +0000222 unsigned long size, addr;
Huang Ying67eb2e92011-07-13 13:14:25 +0800223
224 ghes_estatus_pool_size_request += PAGE_ALIGN(len);
225 size = gen_pool_size(ghes_estatus_pool);
226 if (size >= ghes_estatus_pool_size_request)
227 return 0;
Huang Ying67eb2e92011-07-13 13:14:25 +0800228
James Morse54a87fd2019-01-29 18:48:39 +0000229 addr = (unsigned long)vmalloc(PAGE_ALIGN(len));
230 if (!addr)
231 return -ENOMEM;
232
233 /*
234 * New allocation must be visible in all pgd before it can be found by
235 * an NMI allocating from the pool.
236 */
237 vmalloc_sync_all();
238
239 return gen_pool_add(ghes_estatus_pool, addr, PAGE_ALIGN(len), -1);
Huang Ying67eb2e92011-07-13 13:14:25 +0800240}
241
Huang Yingd334a492010-05-18 14:35:20 +0800242static struct ghes *ghes_new(struct acpi_hest_generic *generic)
243{
244 struct ghes *ghes;
245 unsigned int error_block_length;
246 int rc;
247
248 ghes = kzalloc(sizeof(*ghes), GFP_KERNEL);
249 if (!ghes)
250 return ERR_PTR(-ENOMEM);
251 ghes->generic = generic;
Huang Ying34ddeb02012-06-12 11:20:19 +0800252 rc = apei_map_generic_address(&generic->error_status_address);
Huang Yingd334a492010-05-18 14:35:20 +0800253 if (rc)
254 goto err_free;
255 error_block_length = generic->error_block_length;
256 if (error_block_length > GHES_ESTATUS_MAX_SIZE) {
257 pr_warning(FW_WARN GHES_PFX
258 "Error status block length is too long: %u for "
259 "generic hardware error source: %d.\n",
260 error_block_length, generic->header.source_id);
261 error_block_length = GHES_ESTATUS_MAX_SIZE;
262 }
263 ghes->estatus = kmalloc(error_block_length, GFP_KERNEL);
264 if (!ghes->estatus) {
265 rc = -ENOMEM;
266 goto err_unmap;
267 }
268
269 return ghes;
270
271err_unmap:
Huang Ying34ddeb02012-06-12 11:20:19 +0800272 apei_unmap_generic_address(&generic->error_status_address);
Huang Yingd334a492010-05-18 14:35:20 +0800273err_free:
274 kfree(ghes);
275 return ERR_PTR(rc);
276}
277
278static void ghes_fini(struct ghes *ghes)
279{
280 kfree(ghes->estatus);
Huang Ying34ddeb02012-06-12 11:20:19 +0800281 apei_unmap_generic_address(&ghes->generic->error_status_address);
Huang Yingd334a492010-05-18 14:35:20 +0800282}
283
Huang Yingd334a492010-05-18 14:35:20 +0800284static inline int ghes_severity(int severity)
285{
286 switch (severity) {
Huang Yingad4ecef2010-08-02 15:48:23 +0800287 case CPER_SEV_INFORMATIONAL:
288 return GHES_SEV_NO;
289 case CPER_SEV_CORRECTED:
290 return GHES_SEV_CORRECTED;
291 case CPER_SEV_RECOVERABLE:
292 return GHES_SEV_RECOVERABLE;
293 case CPER_SEV_FATAL:
294 return GHES_SEV_PANIC;
Huang Yingd334a492010-05-18 14:35:20 +0800295 default:
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300296 /* Unknown, go panic */
Huang Yingad4ecef2010-08-02 15:48:23 +0800297 return GHES_SEV_PANIC;
Huang Yingd334a492010-05-18 14:35:20 +0800298 }
299}
300
Huang Ying81e88fd2011-01-12 14:44:55 +0800301static void ghes_copy_tofrom_phys(void *buffer, u64 paddr, u32 len,
302 int from_phys)
Huang Yingd334a492010-05-18 14:35:20 +0800303{
Huang Ying81e88fd2011-01-12 14:44:55 +0800304 void __iomem *vaddr;
305 unsigned long flags = 0;
306 int in_nmi = in_nmi();
307 u64 offset;
308 u32 trunk;
Huang Yingd334a492010-05-18 14:35:20 +0800309
Huang Ying81e88fd2011-01-12 14:44:55 +0800310 while (len > 0) {
311 offset = paddr - (paddr & PAGE_MASK);
312 if (in_nmi) {
313 raw_spin_lock(&ghes_ioremap_lock_nmi);
314 vaddr = ghes_ioremap_pfn_nmi(paddr >> PAGE_SHIFT);
315 } else {
316 spin_lock_irqsave(&ghes_ioremap_lock_irq, flags);
317 vaddr = ghes_ioremap_pfn_irq(paddr >> PAGE_SHIFT);
318 }
319 trunk = PAGE_SIZE - offset;
320 trunk = min(trunk, len);
321 if (from_phys)
322 memcpy_fromio(buffer, vaddr + offset, trunk);
323 else
324 memcpy_toio(vaddr + offset, buffer, trunk);
325 len -= trunk;
326 paddr += trunk;
327 buffer += trunk;
328 if (in_nmi) {
329 ghes_iounmap_nmi(vaddr);
330 raw_spin_unlock(&ghes_ioremap_lock_nmi);
331 } else {
332 ghes_iounmap_irq(vaddr);
333 spin_unlock_irqrestore(&ghes_ioremap_lock_irq, flags);
334 }
335 }
Huang Yingd334a492010-05-18 14:35:20 +0800336}
337
338static int ghes_read_estatus(struct ghes *ghes, int silent)
339{
340 struct acpi_hest_generic *g = ghes->generic;
341 u64 buf_paddr;
342 u32 len;
343 int rc;
344
Myron Stowe700130b2011-11-07 16:23:41 -0700345 rc = apei_read(&buf_paddr, &g->error_status_address);
Huang Yingd334a492010-05-18 14:35:20 +0800346 if (rc) {
347 if (!silent && printk_ratelimit())
348 pr_warning(FW_WARN GHES_PFX
349"Failed to read error status block address for hardware error source: %d.\n",
350 g->header.source_id);
351 return -EIO;
352 }
353 if (!buf_paddr)
354 return -ENOENT;
355
Huang Ying81e88fd2011-01-12 14:44:55 +0800356 ghes_copy_tofrom_phys(ghes->estatus, buf_paddr,
357 sizeof(*ghes->estatus), 1);
Huang Yingd334a492010-05-18 14:35:20 +0800358 if (!ghes->estatus->block_status)
359 return -ENOENT;
360
361 ghes->buffer_paddr = buf_paddr;
362 ghes->flags |= GHES_TO_CLEAR;
363
364 rc = -EIO;
Chen, Gong88f074f2013-10-18 14:28:59 -0700365 len = cper_estatus_len(ghes->estatus);
Huang Yingd334a492010-05-18 14:35:20 +0800366 if (len < sizeof(*ghes->estatus))
367 goto err_read_block;
368 if (len > ghes->generic->error_block_length)
369 goto err_read_block;
Chen, Gong88f074f2013-10-18 14:28:59 -0700370 if (cper_estatus_check_header(ghes->estatus))
Huang Yingd334a492010-05-18 14:35:20 +0800371 goto err_read_block;
Huang Ying81e88fd2011-01-12 14:44:55 +0800372 ghes_copy_tofrom_phys(ghes->estatus + 1,
373 buf_paddr + sizeof(*ghes->estatus),
374 len - sizeof(*ghes->estatus), 1);
Chen, Gong88f074f2013-10-18 14:28:59 -0700375 if (cper_estatus_check(ghes->estatus))
Huang Yingd334a492010-05-18 14:35:20 +0800376 goto err_read_block;
377 rc = 0;
378
379err_read_block:
Huang Ying81e88fd2011-01-12 14:44:55 +0800380 if (rc && !silent && printk_ratelimit())
Huang Yingd334a492010-05-18 14:35:20 +0800381 pr_warning(FW_WARN GHES_PFX
382 "Failed to read error status block!\n");
383 return rc;
384}
385
386static void ghes_clear_estatus(struct ghes *ghes)
387{
388 ghes->estatus->block_status = 0;
389 if (!(ghes->flags & GHES_TO_CLEAR))
390 return;
391 ghes_copy_tofrom_phys(ghes->estatus, ghes->buffer_paddr,
392 sizeof(ghes->estatus->block_status), 0);
393 ghes->flags &= ~GHES_TO_CLEAR;
394}
395
Lv Zheng0a00fd52014-06-03 16:32:53 +0800396static void ghes_handle_memory_failure(struct acpi_hest_generic_data *gdata, int sev)
Naveen N. Raocf870c72013-07-10 14:57:01 +0530397{
398#ifdef CONFIG_ACPI_APEI_MEMORY_FAILURE
399 unsigned long pfn;
Chen, Gongca104ed2013-11-25 02:15:01 -0500400 int flags = -1;
Naveen N. Raocf870c72013-07-10 14:57:01 +0530401 int sec_sev = ghes_severity(gdata->error_severity);
402 struct cper_sec_mem_err *mem_err;
403 mem_err = (struct cper_sec_mem_err *)(gdata + 1);
404
Chen, Gongca104ed2013-11-25 02:15:01 -0500405 if (!(mem_err->validation_bits & CPER_MEM_VALID_PA))
406 return;
407
408 pfn = mem_err->physical_addr >> PAGE_SHIFT;
409 if (!pfn_valid(pfn)) {
410 pr_warn_ratelimited(FW_WARN GHES_PFX
411 "Invalid address in generic error data: %#llx\n",
412 mem_err->physical_addr);
413 return;
414 }
415
416 /* iff following two events can be handled properly by now */
Naveen N. Raocf870c72013-07-10 14:57:01 +0530417 if (sec_sev == GHES_SEV_CORRECTED &&
Chen, Gongca104ed2013-11-25 02:15:01 -0500418 (gdata->flags & CPER_SEC_ERROR_THRESHOLD_EXCEEDED))
419 flags = MF_SOFT_OFFLINE;
420 if (sev == GHES_SEV_RECOVERABLE && sec_sev == GHES_SEV_RECOVERABLE)
421 flags = 0;
422
423 if (flags != -1)
424 memory_failure_queue(pfn, 0, flags);
Naveen N. Raocf870c72013-07-10 14:57:01 +0530425#endif
426}
427
Mauro Carvalho Chehab21480542013-02-15 06:10:39 -0300428static void ghes_do_proc(struct ghes *ghes,
Lv Zheng0a00fd52014-06-03 16:32:53 +0800429 const struct acpi_hest_generic_status *estatus)
Huang Yingd334a492010-05-18 14:35:20 +0800430{
Huang Yingba61ca42011-07-13 13:14:28 +0800431 int sev, sec_sev;
Lv Zheng0a00fd52014-06-03 16:32:53 +0800432 struct acpi_hest_generic_data *gdata;
Huang Yingd334a492010-05-18 14:35:20 +0800433
Huang Ying67eb2e92011-07-13 13:14:25 +0800434 sev = ghes_severity(estatus->error_severity);
435 apei_estatus_for_each_section(estatus, gdata) {
Huang Yingba61ca42011-07-13 13:14:28 +0800436 sec_sev = ghes_severity(gdata->error_severity);
Huang Yingd334a492010-05-18 14:35:20 +0800437 if (!uuid_le_cmp(*(uuid_le *)gdata->section_type,
438 CPER_SEC_PLATFORM_MEM)) {
Huang Yingba61ca42011-07-13 13:14:28 +0800439 struct cper_sec_mem_err *mem_err;
440 mem_err = (struct cper_sec_mem_err *)(gdata+1);
Mauro Carvalho Chehab21480542013-02-15 06:10:39 -0300441 ghes_edac_report_mem_error(ghes, sev, mem_err);
442
Tomasz Nowicki9dae3d02014-07-22 11:20:11 +0200443 arch_apei_report_mem_error(sev, mem_err);
Naveen N. Raocf870c72013-07-10 14:57:01 +0530444 ghes_handle_memory_failure(gdata, sev);
Huang Yingba61ca42011-07-13 13:14:28 +0800445 }
Huang Yinga654e5e2011-12-08 11:25:41 +0800446#ifdef CONFIG_ACPI_APEI_PCIEAER
447 else if (!uuid_le_cmp(*(uuid_le *)gdata->section_type,
448 CPER_SEC_PCIE)) {
449 struct cper_sec_pcie *pcie_err;
450 pcie_err = (struct cper_sec_pcie *)(gdata+1);
451 if (sev == GHES_SEV_RECOVERABLE &&
452 sec_sev == GHES_SEV_RECOVERABLE &&
453 pcie_err->validation_bits & CPER_PCIE_VALID_DEVICE_ID &&
454 pcie_err->validation_bits & CPER_PCIE_VALID_AER_INFO) {
455 unsigned int devfn;
456 int aer_severity;
Betty Dall0ba98ec2013-06-06 12:10:50 -0600457
Huang Yinga654e5e2011-12-08 11:25:41 +0800458 devfn = PCI_DEVFN(pcie_err->device_id.device,
459 pcie_err->device_id.function);
Tyler Baicar2458d662016-09-14 15:14:46 -0600460 aer_severity = cper_severity_to_aer(gdata->error_severity);
Betty Dall0ba98ec2013-06-06 12:10:50 -0600461
462 /*
463 * If firmware reset the component to contain
464 * the error, we must reinitialize it before
465 * use, so treat it as a fatal AER error.
466 */
467 if (gdata->flags & CPER_SEC_RESET)
468 aer_severity = AER_FATAL;
469
Huang Yinga654e5e2011-12-08 11:25:41 +0800470 aer_recover_queue(pcie_err->device_id.segment,
471 pcie_err->device_id.bus,
Lance Ortiz37448ad2013-05-30 08:25:12 -0600472 devfn, aer_severity,
473 (struct aer_capability_regs *)
474 pcie_err->aer_info);
Huang Yinga654e5e2011-12-08 11:25:41 +0800475 }
476
477 }
478#endif
Huang Yingd334a492010-05-18 14:35:20 +0800479 }
Huang Ying32c361f2010-12-07 10:22:31 +0800480}
Huang Yingd334a492010-05-18 14:35:20 +0800481
Huang Ying67eb2e92011-07-13 13:14:25 +0800482static void __ghes_print_estatus(const char *pfx,
483 const struct acpi_hest_generic *generic,
Lv Zheng0a00fd52014-06-03 16:32:53 +0800484 const struct acpi_hest_generic_status *estatus)
Huang Ying32c361f2010-12-07 10:22:31 +0800485{
Huang Ying5ba82ab2011-12-08 11:25:44 +0800486 static atomic_t seqno;
487 unsigned int curr_seqno;
488 char pfx_seq[64];
489
Huang Ying32c361f2010-12-07 10:22:31 +0800490 if (pfx == NULL) {
Huang Ying67eb2e92011-07-13 13:14:25 +0800491 if (ghes_severity(estatus->error_severity) <=
Huang Ying32c361f2010-12-07 10:22:31 +0800492 GHES_SEV_CORRECTED)
Huang Ying5ba82ab2011-12-08 11:25:44 +0800493 pfx = KERN_WARNING;
Huang Ying32c361f2010-12-07 10:22:31 +0800494 else
Huang Ying5ba82ab2011-12-08 11:25:44 +0800495 pfx = KERN_ERR;
Huang Ying32c361f2010-12-07 10:22:31 +0800496 }
Huang Ying5ba82ab2011-12-08 11:25:44 +0800497 curr_seqno = atomic_inc_return(&seqno);
498 snprintf(pfx_seq, sizeof(pfx_seq), "%s{%u}" HW_ERR, pfx, curr_seqno);
Huang Ying55883402011-07-13 13:14:15 +0800499 printk("%s""Hardware error from APEI Generic Hardware Error Source: %d\n",
Huang Ying5ba82ab2011-12-08 11:25:44 +0800500 pfx_seq, generic->header.source_id);
Chen, Gong88f074f2013-10-18 14:28:59 -0700501 cper_estatus_print(pfx_seq, estatus);
Huang Ying55883402011-07-13 13:14:15 +0800502}
503
Huang Ying152cef42011-07-13 13:14:26 +0800504static int ghes_print_estatus(const char *pfx,
505 const struct acpi_hest_generic *generic,
Lv Zheng0a00fd52014-06-03 16:32:53 +0800506 const struct acpi_hest_generic_status *estatus)
Huang Ying55883402011-07-13 13:14:15 +0800507{
508 /* Not more than 2 messages every 5 seconds */
Huang Ying67eb2e92011-07-13 13:14:25 +0800509 static DEFINE_RATELIMIT_STATE(ratelimit_corrected, 5*HZ, 2);
510 static DEFINE_RATELIMIT_STATE(ratelimit_uncorrected, 5*HZ, 2);
511 struct ratelimit_state *ratelimit;
Huang Ying55883402011-07-13 13:14:15 +0800512
Huang Ying67eb2e92011-07-13 13:14:25 +0800513 if (ghes_severity(estatus->error_severity) <= GHES_SEV_CORRECTED)
514 ratelimit = &ratelimit_corrected;
515 else
516 ratelimit = &ratelimit_uncorrected;
Huang Ying152cef42011-07-13 13:14:26 +0800517 if (__ratelimit(ratelimit)) {
Huang Ying67eb2e92011-07-13 13:14:25 +0800518 __ghes_print_estatus(pfx, generic, estatus);
Huang Ying152cef42011-07-13 13:14:26 +0800519 return 1;
520 }
521 return 0;
522}
523
524/*
525 * GHES error status reporting throttle, to report more kinds of
526 * errors, instead of just most frequently occurred errors.
527 */
Lv Zheng0a00fd52014-06-03 16:32:53 +0800528static int ghes_estatus_cached(struct acpi_hest_generic_status *estatus)
Huang Ying152cef42011-07-13 13:14:26 +0800529{
530 u32 len;
531 int i, cached = 0;
532 unsigned long long now;
533 struct ghes_estatus_cache *cache;
Lv Zheng0a00fd52014-06-03 16:32:53 +0800534 struct acpi_hest_generic_status *cache_estatus;
Huang Ying152cef42011-07-13 13:14:26 +0800535
Chen, Gong88f074f2013-10-18 14:28:59 -0700536 len = cper_estatus_len(estatus);
Huang Ying152cef42011-07-13 13:14:26 +0800537 rcu_read_lock();
538 for (i = 0; i < GHES_ESTATUS_CACHES_SIZE; i++) {
539 cache = rcu_dereference(ghes_estatus_caches[i]);
540 if (cache == NULL)
541 continue;
542 if (len != cache->estatus_len)
543 continue;
544 cache_estatus = GHES_ESTATUS_FROM_CACHE(cache);
545 if (memcmp(estatus, cache_estatus, len))
546 continue;
547 atomic_inc(&cache->count);
548 now = sched_clock();
549 if (now - cache->time_in < GHES_ESTATUS_IN_CACHE_MAX_NSEC)
550 cached = 1;
551 break;
552 }
553 rcu_read_unlock();
554 return cached;
555}
556
557static struct ghes_estatus_cache *ghes_estatus_cache_alloc(
558 struct acpi_hest_generic *generic,
Lv Zheng0a00fd52014-06-03 16:32:53 +0800559 struct acpi_hest_generic_status *estatus)
Huang Ying152cef42011-07-13 13:14:26 +0800560{
561 int alloced;
562 u32 len, cache_len;
563 struct ghes_estatus_cache *cache;
Lv Zheng0a00fd52014-06-03 16:32:53 +0800564 struct acpi_hest_generic_status *cache_estatus;
Huang Ying152cef42011-07-13 13:14:26 +0800565
566 alloced = atomic_add_return(1, &ghes_estatus_cache_alloced);
567 if (alloced > GHES_ESTATUS_CACHE_ALLOCED_MAX) {
568 atomic_dec(&ghes_estatus_cache_alloced);
569 return NULL;
570 }
Chen, Gong88f074f2013-10-18 14:28:59 -0700571 len = cper_estatus_len(estatus);
Huang Ying152cef42011-07-13 13:14:26 +0800572 cache_len = GHES_ESTATUS_CACHE_LEN(len);
573 cache = (void *)gen_pool_alloc(ghes_estatus_pool, cache_len);
574 if (!cache) {
575 atomic_dec(&ghes_estatus_cache_alloced);
576 return NULL;
577 }
578 cache_estatus = GHES_ESTATUS_FROM_CACHE(cache);
579 memcpy(cache_estatus, estatus, len);
580 cache->estatus_len = len;
581 atomic_set(&cache->count, 0);
582 cache->generic = generic;
583 cache->time_in = sched_clock();
584 return cache;
585}
586
587static void ghes_estatus_cache_free(struct ghes_estatus_cache *cache)
588{
589 u32 len;
590
Chen, Gong88f074f2013-10-18 14:28:59 -0700591 len = cper_estatus_len(GHES_ESTATUS_FROM_CACHE(cache));
Huang Ying152cef42011-07-13 13:14:26 +0800592 len = GHES_ESTATUS_CACHE_LEN(len);
593 gen_pool_free(ghes_estatus_pool, (unsigned long)cache, len);
594 atomic_dec(&ghes_estatus_cache_alloced);
595}
596
597static void ghes_estatus_cache_rcu_free(struct rcu_head *head)
598{
599 struct ghes_estatus_cache *cache;
600
601 cache = container_of(head, struct ghes_estatus_cache, rcu);
602 ghes_estatus_cache_free(cache);
603}
604
605static void ghes_estatus_cache_add(
606 struct acpi_hest_generic *generic,
Lv Zheng0a00fd52014-06-03 16:32:53 +0800607 struct acpi_hest_generic_status *estatus)
Huang Ying152cef42011-07-13 13:14:26 +0800608{
609 int i, slot = -1, count;
610 unsigned long long now, duration, period, max_period = 0;
611 struct ghes_estatus_cache *cache, *slot_cache = NULL, *new_cache;
612
613 new_cache = ghes_estatus_cache_alloc(generic, estatus);
614 if (new_cache == NULL)
615 return;
616 rcu_read_lock();
617 now = sched_clock();
618 for (i = 0; i < GHES_ESTATUS_CACHES_SIZE; i++) {
619 cache = rcu_dereference(ghes_estatus_caches[i]);
620 if (cache == NULL) {
621 slot = i;
622 slot_cache = NULL;
623 break;
624 }
625 duration = now - cache->time_in;
626 if (duration >= GHES_ESTATUS_IN_CACHE_MAX_NSEC) {
627 slot = i;
628 slot_cache = cache;
629 break;
630 }
631 count = atomic_read(&cache->count);
Len Brown70cb6e12011-08-02 18:00:21 -0400632 period = duration;
633 do_div(period, (count + 1));
Huang Ying152cef42011-07-13 13:14:26 +0800634 if (period > max_period) {
635 max_period = period;
636 slot = i;
637 slot_cache = cache;
638 }
639 }
640 /* new_cache must be put into array after its contents are written */
641 smp_wmb();
642 if (slot != -1 && cmpxchg(ghes_estatus_caches + slot,
643 slot_cache, new_cache) == slot_cache) {
644 if (slot_cache)
645 call_rcu(&slot_cache->rcu, ghes_estatus_cache_rcu_free);
646 } else
647 ghes_estatus_cache_free(new_cache);
648 rcu_read_unlock();
Huang Yingd334a492010-05-18 14:35:20 +0800649}
650
651static int ghes_proc(struct ghes *ghes)
652{
653 int rc;
654
655 rc = ghes_read_estatus(ghes, 0);
656 if (rc)
657 goto out;
Huang Ying152cef42011-07-13 13:14:26 +0800658 if (!ghes_estatus_cached(ghes->estatus)) {
659 if (ghes_print_estatus(NULL, ghes->generic, ghes->estatus))
660 ghes_estatus_cache_add(ghes->generic, ghes->estatus);
661 }
Mauro Carvalho Chehab21480542013-02-15 06:10:39 -0300662 ghes_do_proc(ghes, ghes->estatus);
Huang Yingd334a492010-05-18 14:35:20 +0800663out:
664 ghes_clear_estatus(ghes);
Punit Agrawal806487a2016-10-18 17:07:19 +0100665 return rc;
Huang Yingd334a492010-05-18 14:35:20 +0800666}
667
Huang Ying81e88fd2011-01-12 14:44:55 +0800668static void ghes_add_timer(struct ghes *ghes)
669{
670 struct acpi_hest_generic *g = ghes->generic;
671 unsigned long expire;
672
673 if (!g->notify.poll_interval) {
674 pr_warning(FW_WARN GHES_PFX "Poll interval is 0 for generic hardware error source: %d, disabled.\n",
675 g->header.source_id);
676 return;
677 }
678 expire = jiffies + msecs_to_jiffies(g->notify.poll_interval);
679 ghes->timer.expires = round_jiffies_relative(expire);
680 add_timer(&ghes->timer);
681}
682
683static void ghes_poll_func(unsigned long data)
684{
685 struct ghes *ghes = (void *)data;
686
687 ghes_proc(ghes);
688 if (!(ghes->flags & GHES_EXITING))
689 ghes_add_timer(ghes);
690}
691
692static irqreturn_t ghes_irq_func(int irq, void *data)
693{
694 struct ghes *ghes = data;
695 int rc;
696
697 rc = ghes_proc(ghes);
698 if (rc)
699 return IRQ_NONE;
700
701 return IRQ_HANDLED;
702}
703
Huang Yingd334a492010-05-18 14:35:20 +0800704static int ghes_notify_sci(struct notifier_block *this,
705 unsigned long event, void *data)
706{
707 struct ghes *ghes;
708 int ret = NOTIFY_DONE;
709
710 rcu_read_lock();
711 list_for_each_entry_rcu(ghes, &ghes_sci, list) {
712 if (!ghes_proc(ghes))
713 ret = NOTIFY_OK;
714 }
715 rcu_read_unlock();
716
717 return ret;
718}
719
Tomasz Nowicki44a69f62014-07-22 11:20:12 +0200720static struct notifier_block ghes_notifier_sci = {
721 .notifier_call = ghes_notify_sci,
722};
723
724#ifdef CONFIG_HAVE_ACPI_APEI_NMI
725/*
726 * printk is not safe in NMI context. So in NMI handler, we allocate
727 * required memory from lock-less memory allocator
728 * (ghes_estatus_pool), save estatus into it, put them into lock-less
729 * list (ghes_estatus_llist), then delay printk into IRQ context via
730 * irq_work (ghes_proc_irq_work). ghes_estatus_size_request record
731 * required pool size by all NMI error source.
732 */
733static struct llist_head ghes_estatus_llist;
734static struct irq_work ghes_proc_irq_work;
735
736/*
Jiri Kosina6fe9e7c2015-03-27 10:05:00 +0100737 * NMI may be triggered on any CPU, so ghes_in_nmi is used for
738 * having only one concurrent reader.
Tomasz Nowicki44a69f62014-07-22 11:20:12 +0200739 */
Jiri Kosina6fe9e7c2015-03-27 10:05:00 +0100740static atomic_t ghes_in_nmi = ATOMIC_INIT(0);
Tomasz Nowicki44a69f62014-07-22 11:20:12 +0200741
742static LIST_HEAD(ghes_nmi);
743
744static int ghes_panic_timeout __read_mostly = 30;
745
Huang Ying46d12f02011-12-08 11:25:45 +0800746static void ghes_proc_in_irq(struct irq_work *irq_work)
747{
748 struct llist_node *llnode, *next;
749 struct ghes_estatus_node *estatus_node;
750 struct acpi_hest_generic *generic;
Lv Zheng0a00fd52014-06-03 16:32:53 +0800751 struct acpi_hest_generic_status *estatus;
Huang Ying46d12f02011-12-08 11:25:45 +0800752 u32 len, node_len;
753
754 llnode = llist_del_all(&ghes_estatus_llist);
755 /*
756 * Because the time order of estatus in list is reversed,
757 * revert it back to proper order.
758 */
Chen, Gong8d21d4c2014-07-28 02:50:59 -0400759 llnode = llist_reverse_order(llnode);
Huang Ying67eb2e92011-07-13 13:14:25 +0800760 while (llnode) {
761 next = llnode->next;
762 estatus_node = llist_entry(llnode, struct ghes_estatus_node,
763 llnode);
764 estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
Chen, Gong88f074f2013-10-18 14:28:59 -0700765 len = cper_estatus_len(estatus);
Huang Ying67eb2e92011-07-13 13:14:25 +0800766 node_len = GHES_ESTATUS_NODE_LEN(len);
Mauro Carvalho Chehab21480542013-02-15 06:10:39 -0300767 ghes_do_proc(estatus_node->ghes, estatus);
Huang Ying152cef42011-07-13 13:14:26 +0800768 if (!ghes_estatus_cached(estatus)) {
769 generic = estatus_node->generic;
770 if (ghes_print_estatus(NULL, generic, estatus))
771 ghes_estatus_cache_add(generic, estatus);
772 }
Huang Ying67eb2e92011-07-13 13:14:25 +0800773 gen_pool_free(ghes_estatus_pool, (unsigned long)estatus_node,
774 node_len);
775 llnode = next;
776 }
777}
778
Huang Ying46d12f02011-12-08 11:25:45 +0800779static void ghes_print_queued_estatus(void)
780{
781 struct llist_node *llnode;
782 struct ghes_estatus_node *estatus_node;
783 struct acpi_hest_generic *generic;
Lv Zheng0a00fd52014-06-03 16:32:53 +0800784 struct acpi_hest_generic_status *estatus;
Huang Ying46d12f02011-12-08 11:25:45 +0800785 u32 len, node_len;
786
787 llnode = llist_del_all(&ghes_estatus_llist);
788 /*
789 * Because the time order of estatus in list is reversed,
790 * revert it back to proper order.
791 */
Chen, Gong8d21d4c2014-07-28 02:50:59 -0400792 llnode = llist_reverse_order(llnode);
Huang Ying46d12f02011-12-08 11:25:45 +0800793 while (llnode) {
794 estatus_node = llist_entry(llnode, struct ghes_estatus_node,
795 llnode);
796 estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
Chen, Gong88f074f2013-10-18 14:28:59 -0700797 len = cper_estatus_len(estatus);
Huang Ying46d12f02011-12-08 11:25:45 +0800798 node_len = GHES_ESTATUS_NODE_LEN(len);
799 generic = estatus_node->generic;
800 ghes_print_estatus(NULL, generic, estatus);
801 llnode = llnode->next;
802 }
803}
804
Borislav Petkov11568492015-03-18 09:41:35 +0100805/* Save estatus for further processing in IRQ context */
806static void __process_error(struct ghes *ghes)
807{
808#ifdef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
809 u32 len, node_len;
810 struct ghes_estatus_node *estatus_node;
811 struct acpi_hest_generic_status *estatus;
812
813 if (ghes_estatus_cached(ghes->estatus))
814 return;
815
816 len = cper_estatus_len(ghes->estatus);
817 node_len = GHES_ESTATUS_NODE_LEN(len);
818
819 estatus_node = (void *)gen_pool_alloc(ghes_estatus_pool, node_len);
820 if (!estatus_node)
821 return;
822
823 estatus_node->ghes = ghes;
824 estatus_node->generic = ghes->generic;
825 estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
826 memcpy(estatus, ghes->estatus, len);
827 llist_add(&estatus_node->llnode, &ghes_estatus_llist);
828#endif
829}
830
Borislav Petkove10be032015-03-18 09:52:39 +0100831static void __ghes_panic(struct ghes *ghes)
832{
833 oops_begin();
834 ghes_print_queued_estatus();
835 __ghes_print_estatus(KERN_EMERG, ghes->generic, ghes->estatus);
836
837 /* reboot to log the error! */
838 if (panic_timeout == 0)
839 panic_timeout = ghes_panic_timeout;
840 panic("Fatal hardware error!");
841}
842
Don Zickus9c48f1c2011-09-30 15:06:21 -0400843static int ghes_notify_nmi(unsigned int cmd, struct pt_regs *regs)
Huang Ying81e88fd2011-01-12 14:44:55 +0800844{
Borislav Petkov6169ddf2015-03-18 09:55:21 +0100845 struct ghes *ghes;
846 int sev, ret = NMI_DONE;
Huang Ying81e88fd2011-01-12 14:44:55 +0800847
Jiri Kosina6fe9e7c2015-03-27 10:05:00 +0100848 if (!atomic_add_unless(&ghes_in_nmi, 1, 1))
849 return ret;
850
Huang Ying81e88fd2011-01-12 14:44:55 +0800851 list_for_each_entry_rcu(ghes, &ghes_nmi, list) {
852 if (ghes_read_estatus(ghes, 1)) {
853 ghes_clear_estatus(ghes);
854 continue;
Prarit Bhargavaf53cfb02016-11-30 08:19:39 -0500855 } else {
856 ret = NMI_HANDLED;
Huang Ying81e88fd2011-01-12 14:44:55 +0800857 }
Borislav Petkov6169ddf2015-03-18 09:55:21 +0100858
Huang Ying81e88fd2011-01-12 14:44:55 +0800859 sev = ghes_severity(ghes->estatus->error_severity);
Borislav Petkov6169ddf2015-03-18 09:55:21 +0100860 if (sev >= GHES_SEV_PANIC)
861 __ghes_panic(ghes);
862
Huang Ying81e88fd2011-01-12 14:44:55 +0800863 if (!(ghes->flags & GHES_TO_CLEAR))
864 continue;
Borislav Petkov11568492015-03-18 09:41:35 +0100865
866 __process_error(ghes);
Huang Ying81e88fd2011-01-12 14:44:55 +0800867 ghes_clear_estatus(ghes);
868 }
Borislav Petkov11568492015-03-18 09:41:35 +0100869
Huang Ying67eb2e92011-07-13 13:14:25 +0800870#ifdef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
Prarit Bhargavaf53cfb02016-11-30 08:19:39 -0500871 if (ret == NMI_HANDLED)
872 irq_work_queue(&ghes_proc_irq_work);
Huang Ying67eb2e92011-07-13 13:14:25 +0800873#endif
Jiri Kosina6fe9e7c2015-03-27 10:05:00 +0100874 atomic_dec(&ghes_in_nmi);
Huang Ying81e88fd2011-01-12 14:44:55 +0800875 return ret;
876}
877
Huang Ying67eb2e92011-07-13 13:14:25 +0800878static unsigned long ghes_esource_prealloc_size(
879 const struct acpi_hest_generic *generic)
880{
881 unsigned long block_length, prealloc_records, prealloc_size;
882
883 block_length = min_t(unsigned long, generic->error_block_length,
884 GHES_ESTATUS_MAX_SIZE);
885 prealloc_records = max_t(unsigned long,
886 generic->records_to_preallocate, 1);
887 prealloc_size = min_t(unsigned long, block_length * prealloc_records,
888 GHES_ESOURCE_PREALLOC_MAX_SIZE);
889
890 return prealloc_size;
891}
892
Tomasz Nowicki44a69f62014-07-22 11:20:12 +0200893static void ghes_estatus_pool_shrink(unsigned long len)
894{
895 ghes_estatus_pool_size_request -= PAGE_ALIGN(len);
896}
897
898static void ghes_nmi_add(struct ghes *ghes)
899{
900 unsigned long len;
901
902 len = ghes_esource_prealloc_size(ghes->generic);
903 ghes_estatus_pool_expand(len);
904 mutex_lock(&ghes_list_mutex);
905 if (list_empty(&ghes_nmi))
906 register_nmi_handler(NMI_LOCAL, ghes_notify_nmi, 0, "ghes");
907 list_add_rcu(&ghes->list, &ghes_nmi);
908 mutex_unlock(&ghes_list_mutex);
909}
910
911static void ghes_nmi_remove(struct ghes *ghes)
912{
913 unsigned long len;
914
915 mutex_lock(&ghes_list_mutex);
916 list_del_rcu(&ghes->list);
917 if (list_empty(&ghes_nmi))
918 unregister_nmi_handler(NMI_LOCAL, "ghes");
919 mutex_unlock(&ghes_list_mutex);
920 /*
921 * To synchronize with NMI handler, ghes can only be
922 * freed after NMI handler finishes.
923 */
924 synchronize_rcu();
925 len = ghes_esource_prealloc_size(ghes->generic);
926 ghes_estatus_pool_shrink(len);
927}
928
929static void ghes_nmi_init_cxt(void)
930{
931 init_irq_work(&ghes_proc_irq_work, ghes_proc_in_irq);
932}
933#else /* CONFIG_HAVE_ACPI_APEI_NMI */
934static inline void ghes_nmi_add(struct ghes *ghes)
935{
936 pr_err(GHES_PFX "ID: %d, trying to add NMI notification which is not supported!\n",
937 ghes->generic->header.source_id);
938 BUG();
939}
940
941static inline void ghes_nmi_remove(struct ghes *ghes)
942{
943 pr_err(GHES_PFX "ID: %d, trying to remove NMI notification which is not supported!\n",
944 ghes->generic->header.source_id);
945 BUG();
946}
947
948static inline void ghes_nmi_init_cxt(void)
949{
950}
951#endif /* CONFIG_HAVE_ACPI_APEI_NMI */
952
Bill Pembertonda095fd2012-11-19 13:22:46 -0500953static int ghes_probe(struct platform_device *ghes_dev)
Huang Yingd334a492010-05-18 14:35:20 +0800954{
955 struct acpi_hest_generic *generic;
956 struct ghes *ghes = NULL;
Tomasz Nowicki44a69f62014-07-22 11:20:12 +0200957
Huang Ying7ad6e942010-08-02 15:48:24 +0800958 int rc = -EINVAL;
Huang Yingd334a492010-05-18 14:35:20 +0800959
Jin Dongming1dd6b202010-09-29 19:53:53 +0800960 generic = *(struct acpi_hest_generic **)ghes_dev->dev.platform_data;
Huang Yingd334a492010-05-18 14:35:20 +0800961 if (!generic->enabled)
Huang Ying7ad6e942010-08-02 15:48:24 +0800962 return -ENODEV;
Huang Yingd334a492010-05-18 14:35:20 +0800963
Huang Ying81e88fd2011-01-12 14:44:55 +0800964 switch (generic->notify.type) {
965 case ACPI_HEST_NOTIFY_POLLED:
966 case ACPI_HEST_NOTIFY_EXTERNAL:
967 case ACPI_HEST_NOTIFY_SCI:
Tomasz Nowicki44a69f62014-07-22 11:20:12 +0200968 break;
Huang Ying81e88fd2011-01-12 14:44:55 +0800969 case ACPI_HEST_NOTIFY_NMI:
Tomasz Nowicki44a69f62014-07-22 11:20:12 +0200970 if (!IS_ENABLED(CONFIG_HAVE_ACPI_APEI_NMI)) {
971 pr_warn(GHES_PFX "Generic hardware error source: %d notified via NMI interrupt is not supported!\n",
972 generic->header.source_id);
973 goto err;
974 }
Huang Ying81e88fd2011-01-12 14:44:55 +0800975 break;
976 case ACPI_HEST_NOTIFY_LOCAL:
977 pr_warning(GHES_PFX "Generic hardware error source: %d notified via local interrupt is not supported!\n",
Huang Yingd334a492010-05-18 14:35:20 +0800978 generic->header.source_id);
979 goto err;
Huang Ying81e88fd2011-01-12 14:44:55 +0800980 default:
981 pr_warning(FW_WARN GHES_PFX "Unknown notification type: %u for generic hardware error source: %d\n",
982 generic->notify.type, generic->header.source_id);
983 goto err;
Huang Yingd334a492010-05-18 14:35:20 +0800984 }
Huang Ying81e88fd2011-01-12 14:44:55 +0800985
986 rc = -EIO;
987 if (generic->error_block_length <
Lv Zheng0a00fd52014-06-03 16:32:53 +0800988 sizeof(struct acpi_hest_generic_status)) {
Huang Ying81e88fd2011-01-12 14:44:55 +0800989 pr_warning(FW_BUG GHES_PFX "Invalid error block length: %u for generic hardware error source: %d\n",
990 generic->error_block_length,
Huang Yingd334a492010-05-18 14:35:20 +0800991 generic->header.source_id);
992 goto err;
993 }
994 ghes = ghes_new(generic);
995 if (IS_ERR(ghes)) {
996 rc = PTR_ERR(ghes);
997 ghes = NULL;
998 goto err;
999 }
Mauro Carvalho Chehab21480542013-02-15 06:10:39 -03001000
1001 rc = ghes_edac_register(ghes, &ghes_dev->dev);
1002 if (rc < 0)
1003 goto err;
1004
Huang Ying81e88fd2011-01-12 14:44:55 +08001005 switch (generic->notify.type) {
1006 case ACPI_HEST_NOTIFY_POLLED:
1007 ghes->timer.function = ghes_poll_func;
1008 ghes->timer.data = (unsigned long)ghes;
1009 init_timer_deferrable(&ghes->timer);
1010 ghes_add_timer(ghes);
1011 break;
1012 case ACPI_HEST_NOTIFY_EXTERNAL:
1013 /* External interrupt vector is GSI */
Wei Yongjuna98d4f62013-06-03 02:08:39 +00001014 rc = acpi_gsi_to_irq(generic->notify.vector, &ghes->irq);
1015 if (rc) {
Huang Ying81e88fd2011-01-12 14:44:55 +08001016 pr_err(GHES_PFX "Failed to map GSI to IRQ for generic hardware error source: %d\n",
1017 generic->header.source_id);
Mauro Carvalho Chehab21480542013-02-15 06:10:39 -03001018 goto err_edac_unreg;
Huang Ying81e88fd2011-01-12 14:44:55 +08001019 }
Wei Yongjuna98d4f62013-06-03 02:08:39 +00001020 rc = request_irq(ghes->irq, ghes_irq_func, 0, "GHES IRQ", ghes);
1021 if (rc) {
Huang Ying81e88fd2011-01-12 14:44:55 +08001022 pr_err(GHES_PFX "Failed to register IRQ for generic hardware error source: %d\n",
1023 generic->header.source_id);
Mauro Carvalho Chehab21480542013-02-15 06:10:39 -03001024 goto err_edac_unreg;
Huang Ying81e88fd2011-01-12 14:44:55 +08001025 }
1026 break;
1027 case ACPI_HEST_NOTIFY_SCI:
Huang Ying7ad6e942010-08-02 15:48:24 +08001028 mutex_lock(&ghes_list_mutex);
Huang Yingd334a492010-05-18 14:35:20 +08001029 if (list_empty(&ghes_sci))
1030 register_acpi_hed_notifier(&ghes_notifier_sci);
1031 list_add_rcu(&ghes->list, &ghes_sci);
Huang Ying7ad6e942010-08-02 15:48:24 +08001032 mutex_unlock(&ghes_list_mutex);
Huang Ying81e88fd2011-01-12 14:44:55 +08001033 break;
1034 case ACPI_HEST_NOTIFY_NMI:
Tomasz Nowicki44a69f62014-07-22 11:20:12 +02001035 ghes_nmi_add(ghes);
Huang Ying81e88fd2011-01-12 14:44:55 +08001036 break;
1037 default:
1038 BUG();
Huang Yingd334a492010-05-18 14:35:20 +08001039 }
Huang Ying7ad6e942010-08-02 15:48:24 +08001040 platform_set_drvdata(ghes_dev, ghes);
Huang Yingd334a492010-05-18 14:35:20 +08001041
1042 return 0;
Mauro Carvalho Chehab21480542013-02-15 06:10:39 -03001043err_edac_unreg:
1044 ghes_edac_unregister(ghes);
Huang Yingd334a492010-05-18 14:35:20 +08001045err:
Huang Ying7ad6e942010-08-02 15:48:24 +08001046 if (ghes) {
Huang Yingd334a492010-05-18 14:35:20 +08001047 ghes_fini(ghes);
1048 kfree(ghes);
1049 }
Huang Ying7ad6e942010-08-02 15:48:24 +08001050 return rc;
Huang Yingd334a492010-05-18 14:35:20 +08001051}
1052
Bill Pembertonb59bc2f2012-11-21 23:13:09 +01001053static int ghes_remove(struct platform_device *ghes_dev)
Huang Ying7ad6e942010-08-02 15:48:24 +08001054{
1055 struct ghes *ghes;
1056 struct acpi_hest_generic *generic;
1057
1058 ghes = platform_get_drvdata(ghes_dev);
1059 generic = ghes->generic;
1060
Huang Ying81e88fd2011-01-12 14:44:55 +08001061 ghes->flags |= GHES_EXITING;
Huang Ying7ad6e942010-08-02 15:48:24 +08001062 switch (generic->notify.type) {
Huang Ying81e88fd2011-01-12 14:44:55 +08001063 case ACPI_HEST_NOTIFY_POLLED:
1064 del_timer_sync(&ghes->timer);
1065 break;
1066 case ACPI_HEST_NOTIFY_EXTERNAL:
1067 free_irq(ghes->irq, ghes);
1068 break;
Huang Ying7ad6e942010-08-02 15:48:24 +08001069 case ACPI_HEST_NOTIFY_SCI:
1070 mutex_lock(&ghes_list_mutex);
1071 list_del_rcu(&ghes->list);
1072 if (list_empty(&ghes_sci))
1073 unregister_acpi_hed_notifier(&ghes_notifier_sci);
1074 mutex_unlock(&ghes_list_mutex);
James Morse3bc8e4f2017-03-16 14:30:39 +00001075 synchronize_rcu();
Huang Ying7ad6e942010-08-02 15:48:24 +08001076 break;
Huang Ying81e88fd2011-01-12 14:44:55 +08001077 case ACPI_HEST_NOTIFY_NMI:
Tomasz Nowicki44a69f62014-07-22 11:20:12 +02001078 ghes_nmi_remove(ghes);
Huang Ying81e88fd2011-01-12 14:44:55 +08001079 break;
Huang Ying7ad6e942010-08-02 15:48:24 +08001080 default:
1081 BUG();
1082 break;
1083 }
1084
Huang Ying7ad6e942010-08-02 15:48:24 +08001085 ghes_fini(ghes);
Mauro Carvalho Chehab21480542013-02-15 06:10:39 -03001086
1087 ghes_edac_unregister(ghes);
1088
Huang Ying7ad6e942010-08-02 15:48:24 +08001089 kfree(ghes);
1090
1091 platform_set_drvdata(ghes_dev, NULL);
1092
1093 return 0;
1094}
1095
1096static struct platform_driver ghes_platform_driver = {
1097 .driver = {
1098 .name = "GHES",
Huang Ying7ad6e942010-08-02 15:48:24 +08001099 },
1100 .probe = ghes_probe,
1101 .remove = ghes_remove,
1102};
1103
Huang Yingd334a492010-05-18 14:35:20 +08001104static int __init ghes_init(void)
1105{
Huang Ying81e88fd2011-01-12 14:44:55 +08001106 int rc;
1107
Huang Yingd334a492010-05-18 14:35:20 +08001108 if (acpi_disabled)
1109 return -ENODEV;
1110
1111 if (hest_disable) {
1112 pr_info(GHES_PFX "HEST is not enabled!\n");
1113 return -EINVAL;
1114 }
1115
Huang Yingb6a95012011-07-13 13:14:19 +08001116 if (ghes_disable) {
1117 pr_info(GHES_PFX "GHES is not enabled!\n");
1118 return -EINVAL;
1119 }
1120
Tomasz Nowicki44a69f62014-07-22 11:20:12 +02001121 ghes_nmi_init_cxt();
Huang Ying67eb2e92011-07-13 13:14:25 +08001122
Huang Ying81e88fd2011-01-12 14:44:55 +08001123 rc = ghes_ioremap_init();
1124 if (rc)
1125 goto err;
1126
Huang Ying67eb2e92011-07-13 13:14:25 +08001127 rc = ghes_estatus_pool_init();
Huang Ying81e88fd2011-01-12 14:44:55 +08001128 if (rc)
1129 goto err_ioremap_exit;
1130
Huang Ying152cef42011-07-13 13:14:26 +08001131 rc = ghes_estatus_pool_expand(GHES_ESTATUS_CACHE_AVG_SIZE *
1132 GHES_ESTATUS_CACHE_ALLOCED_MAX);
1133 if (rc)
1134 goto err_pool_exit;
1135
Huang Ying67eb2e92011-07-13 13:14:25 +08001136 rc = platform_driver_register(&ghes_platform_driver);
1137 if (rc)
1138 goto err_pool_exit;
1139
Huang Ying9fb0bfe2011-07-13 13:14:21 +08001140 rc = apei_osc_setup();
1141 if (rc == 0 && osc_sb_apei_support_acked)
1142 pr_info(GHES_PFX "APEI firmware first mode is enabled by APEI bit and WHEA _OSC.\n");
1143 else if (rc == 0 && !osc_sb_apei_support_acked)
1144 pr_info(GHES_PFX "APEI firmware first mode is enabled by WHEA _OSC.\n");
1145 else if (rc && osc_sb_apei_support_acked)
1146 pr_info(GHES_PFX "APEI firmware first mode is enabled by APEI bit.\n");
1147 else
1148 pr_info(GHES_PFX "Failed to enable APEI firmware first mode.\n");
1149
Huang Ying81e88fd2011-01-12 14:44:55 +08001150 return 0;
Huang Ying67eb2e92011-07-13 13:14:25 +08001151err_pool_exit:
1152 ghes_estatus_pool_exit();
Huang Ying81e88fd2011-01-12 14:44:55 +08001153err_ioremap_exit:
1154 ghes_ioremap_exit();
1155err:
1156 return rc;
Huang Yingd334a492010-05-18 14:35:20 +08001157}
Paul Gortmaker020bf062016-02-15 00:27:50 -05001158device_initcall(ghes_init);