projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'arm64-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/arm64/linux
[deliverable/linux.git] / drivers / acpi / apei / erst.c
CommitLineData
a08f82d0
HY		 1/*
2 * APEI Error Record Serialization Table support
3 *
4 * ERST is a way provided by APEI to save and retrieve hardware error
58f87ed0 5 * information to and from a persistent store.
a08f82d0
HY		 6 *
7 * For more information about ERST, please refer to ACPI Specification
8 * version 4.0, section 17.4.
9 *
10 * Copyright 2010 Intel Corp.
11 * Author: Huang Ying <ying.huang@intel.com>
12 *
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License version
15 * 2 as published by the Free Software Foundation.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 */
26
27#include <linux/kernel.h>
28#include <linux/module.h>
29#include <linux/init.h>
30#include <linux/delay.h>
31#include <linux/io.h>
32#include <linux/acpi.h>
33#include <linux/uaccess.h>
34#include <linux/cper.h>
35#include <linux/nmi.h>
0a7992c9 36#include <linux/hardirq.h>
0bb77c46 37#include <linux/pstore.h>
d6472302 38#include <linux/vmalloc.h>
a08f82d0
HY		 39#include <acpi/apei.h>
40
41#include "apei-internal.h"
42
cb82a2e4
BP		 43#undef pr_fmt
44#define pr_fmt(fmt) "ERST: " fmt
a08f82d0
HY		 45
46/* ERST command status */
47#define ERST_STATUS_SUCCESS 0x0
48#define ERST_STATUS_NOT_ENOUGH_SPACE 0x1
49#define ERST_STATUS_HARDWARE_NOT_AVAILABLE 0x2
50#define ERST_STATUS_FAILED 0x3
51#define ERST_STATUS_RECORD_STORE_EMPTY 0x4
52#define ERST_STATUS_RECORD_NOT_FOUND 0x5
53
54#define ERST_TAB_ENTRY(tab) \
55 ((struct acpi_whea_header *)((char *)(tab) + \
56 sizeof(struct acpi_table_erst)))
57
58#define SPIN_UNIT 100 /* 100ns */
e8a8b252 59/* Firmware should respond within 1 milliseconds */
a08f82d0
HY		 60#define FIRMWARE_TIMEOUT (1 * NSEC_PER_MSEC)
61#define FIRMWARE_MAX_STALL 50 /* 50us */
62
63int erst_disable;
64EXPORT_SYMBOL_GPL(erst_disable);
65
66static struct acpi_table_erst *erst_tab;
67
68/* ERST Error Log Address Range atrributes */
69#define ERST_RANGE_RESERVED 0x0001
70#define ERST_RANGE_NVRAM 0x0002
71#define ERST_RANGE_SLOW 0x0004
72
73/*
74 * ERST Error Log Address Range, used as buffer for reading/writing
75 * error records.
76 */
77static struct erst_erange {
78 u64 base;
79 u64 size;
80 void __iomem *vaddr;
81 u32 attr;
82} erst_erange;
83
84/*
85 * Prevent ERST interpreter to run simultaneously, because the
86 * corresponding firmware implementation may not work properly when
87 * invoked simultaneously.
88 *
89 * It is used to provide exclusive accessing for ERST Error Log
90 * Address Range too.
91 */
3b38bb5f 92static DEFINE_RAW_SPINLOCK(erst_lock);
a08f82d0
HY		 93
94static inline int erst_errno(int command_status)
95{
96 switch (command_status) {
97 case ERST_STATUS_SUCCESS:
98 return 0;
99 case ERST_STATUS_HARDWARE_NOT_AVAILABLE:
100 return -ENODEV;
101 case ERST_STATUS_NOT_ENOUGH_SPACE:
102 return -ENOSPC;
103 case ERST_STATUS_RECORD_STORE_EMPTY:
104 case ERST_STATUS_RECORD_NOT_FOUND:
105 return -ENOENT;
106 default:
107 return -EINVAL;
108 }
109}
110
111static int erst_timedout(u64 *t, u64 spin_unit)
112{
113 if ((s64)*t < spin_unit) {
cb82a2e4 114 pr_warn(FW_WARN "Firmware does not respond in time.\n");
a08f82d0
HY		 115 return 1;
116 }
117 *t -= spin_unit;
118 ndelay(spin_unit);
119 touch_nmi_watchdog();
120 return 0;
121}
122
123static int erst_exec_load_var1(struct apei_exec_context *ctx,
124 struct acpi_whea_header *entry)
125{
126 return __apei_exec_read_register(entry, &ctx->var1);
127}
128
129static int erst_exec_load_var2(struct apei_exec_context *ctx,
130 struct acpi_whea_header *entry)
131{
132 return __apei_exec_read_register(entry, &ctx->var2);
133}
134
135static int erst_exec_store_var1(struct apei_exec_context *ctx,
136 struct acpi_whea_header *entry)
137{
138 return __apei_exec_write_register(entry, ctx->var1);
139}
140
141static int erst_exec_add(struct apei_exec_context *ctx,
142 struct acpi_whea_header *entry)
143{
144 ctx->var1 += ctx->var2;
145 return 0;
146}
147
148static int erst_exec_subtract(struct apei_exec_context *ctx,
149 struct acpi_whea_header *entry)
150{
151 ctx->var1 -= ctx->var2;
152 return 0;
153}
154
155static int erst_exec_add_value(struct apei_exec_context *ctx,
156 struct acpi_whea_header *entry)
157{
158 int rc;
159 u64 val;
160
161 rc = __apei_exec_read_register(entry, &val);
162 if (rc)
163 return rc;
164 val += ctx->value;
165 rc = __apei_exec_write_register(entry, val);
166 return rc;
167}
168
169static int erst_exec_subtract_value(struct apei_exec_context *ctx,
170 struct acpi_whea_header *entry)
171{
172 int rc;
173 u64 val;
174
175 rc = __apei_exec_read_register(entry, &val);
176 if (rc)
177 return rc;
178 val -= ctx->value;
179 rc = __apei_exec_write_register(entry, val);
180 return rc;
181}
182
183static int erst_exec_stall(struct apei_exec_context *ctx,
184 struct acpi_whea_header *entry)
185{
186 u64 stall_time;
187
188 if (ctx->value > FIRMWARE_MAX_STALL) {
189 if (!in_nmi())
cb82a2e4
BP		 190 pr_warn(FW_WARN
191 "Too long stall time for stall instruction: 0x%llx.\n",
a08f82d0
HY		 192 ctx->value);
193 stall_time = FIRMWARE_MAX_STALL;
194 } else
195 stall_time = ctx->value;
196 udelay(stall_time);
197 return 0;
198}
199
200static int erst_exec_stall_while_true(struct apei_exec_context *ctx,
201 struct acpi_whea_header *entry)
202{
203 int rc;
204 u64 val;
205 u64 timeout = FIRMWARE_TIMEOUT;
206 u64 stall_time;
207
208 if (ctx->var1 > FIRMWARE_MAX_STALL) {
209 if (!in_nmi())
cb82a2e4
BP		 210 pr_warn(FW_WARN
211 "Too long stall time for stall while true instruction: 0x%llx.\n",
a08f82d0
HY		 212 ctx->var1);
213 stall_time = FIRMWARE_MAX_STALL;
214 } else
215 stall_time = ctx->var1;
216
217 for (;;) {
218 rc = __apei_exec_read_register(entry, &val);
219 if (rc)
220 return rc;
221 if (val != ctx->value)
222 break;
223 if (erst_timedout(&timeout, stall_time * NSEC_PER_USEC))
224 return -EIO;
225 }
226 return 0;
227}
228
229static int erst_exec_skip_next_instruction_if_true(
230 struct apei_exec_context *ctx,
231 struct acpi_whea_header *entry)
232{
233 int rc;
234 u64 val;
235
236 rc = __apei_exec_read_register(entry, &val);
237 if (rc)
238 return rc;
239 if (val == ctx->value) {
240 ctx->ip += 2;
241 return APEI_EXEC_SET_IP;
242 }
243
244 return 0;
245}
246
247static int erst_exec_goto(struct apei_exec_context *ctx,
248 struct acpi_whea_header *entry)
249{
250 ctx->ip = ctx->value;
251 return APEI_EXEC_SET_IP;
252}
253
254static int erst_exec_set_src_address_base(struct apei_exec_context *ctx,
255 struct acpi_whea_header *entry)
256{
257 return __apei_exec_read_register(entry, &ctx->src_base);
258}
259
260static int erst_exec_set_dst_address_base(struct apei_exec_context *ctx,
261 struct acpi_whea_header *entry)
262{
263 return __apei_exec_read_register(entry, &ctx->dst_base);
264}
265
266static int erst_exec_move_data(struct apei_exec_context *ctx,
267 struct acpi_whea_header *entry)
268{
269 int rc;
270 u64 offset;
0bbba38a
HY		 271 void *src, *dst;
272
273 /* ioremap does not work in interrupt context */
274 if (in_interrupt()) {
cb82a2e4 275 pr_warn("MOVE_DATA can not be used in interrupt context.\n");
0bbba38a
HY		 276 return -EBUSY;
277 }
a08f82d0
HY		 278
279 rc = __apei_exec_read_register(entry, &offset);
280 if (rc)
281 return rc;
0bbba38a
HY		 282
283 src = ioremap(ctx->src_base + offset, ctx->var2);
284 if (!src)
285 return -ENOMEM;
286 dst = ioremap(ctx->dst_base + offset, ctx->var2);
08b326d0
WY		 287 if (!dst) {
288 iounmap(src);
0bbba38a 289 return -ENOMEM;
08b326d0 290 }
0bbba38a
HY		 291
292 memmove(dst, src, ctx->var2);
293
294 iounmap(src);
295 iounmap(dst);
a08f82d0
HY		 296
297 return 0;
298}
299
300static struct apei_exec_ins_type erst_ins_type[] = {
301 [ACPI_ERST_READ_REGISTER] = {
302 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
303 .run = apei_exec_read_register,
304 },
305 [ACPI_ERST_READ_REGISTER_VALUE] = {
306 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
307 .run = apei_exec_read_register_value,
308 },
309 [ACPI_ERST_WRITE_REGISTER] = {
310 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
311 .run = apei_exec_write_register,
312 },
313 [ACPI_ERST_WRITE_REGISTER_VALUE] = {
314 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
315 .run = apei_exec_write_register_value,
316 },
317 [ACPI_ERST_NOOP] = {
318 .flags = 0,
319 .run = apei_exec_noop,
320 },
321 [ACPI_ERST_LOAD_VAR1] = {
322 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
323 .run = erst_exec_load_var1,
324 },
325 [ACPI_ERST_LOAD_VAR2] = {
326 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
327 .run = erst_exec_load_var2,
328 },
329 [ACPI_ERST_STORE_VAR1] = {
330 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
331 .run = erst_exec_store_var1,
332 },
333 [ACPI_ERST_ADD] = {
334 .flags = 0,
335 .run = erst_exec_add,
336 },
337 [ACPI_ERST_SUBTRACT] = {
338 .flags = 0,
339 .run = erst_exec_subtract,
340 },
341 [ACPI_ERST_ADD_VALUE] = {
342 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
343 .run = erst_exec_add_value,
344 },
345 [ACPI_ERST_SUBTRACT_VALUE] = {
346 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
347 .run = erst_exec_subtract_value,
348 },
349 [ACPI_ERST_STALL] = {
350 .flags = 0,
351 .run = erst_exec_stall,
352 },
353 [ACPI_ERST_STALL_WHILE_TRUE] = {
354 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
355 .run = erst_exec_stall_while_true,
356 },
357 [ACPI_ERST_SKIP_NEXT_IF_TRUE] = {
358 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
359 .run = erst_exec_skip_next_instruction_if_true,
360 },
361 [ACPI_ERST_GOTO] = {
362 .flags = 0,
363 .run = erst_exec_goto,
364 },
365 [ACPI_ERST_SET_SRC_ADDRESS_BASE] = {
366 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
367 .run = erst_exec_set_src_address_base,
368 },
369 [ACPI_ERST_SET_DST_ADDRESS_BASE] = {
370 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
371 .run = erst_exec_set_dst_address_base,
372 },
373 [ACPI_ERST_MOVE_DATA] = {
374 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
375 .run = erst_exec_move_data,
376 },
377};
378
379static inline void erst_exec_ctx_init(struct apei_exec_context *ctx)
380{
381 apei_exec_ctx_init(ctx, erst_ins_type, ARRAY_SIZE(erst_ins_type),
382 ERST_TAB_ENTRY(erst_tab), erst_tab->entries);
383}
384
385static int erst_get_erange(struct erst_erange *range)
386{
387 struct apei_exec_context ctx;
388 int rc;
389
390 erst_exec_ctx_init(&ctx);
391 rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_RANGE);
392 if (rc)
393 return rc;
394 range->base = apei_exec_ctx_get_output(&ctx);
395 rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_LENGTH);
396 if (rc)
397 return rc;
398 range->size = apei_exec_ctx_get_output(&ctx);
399 rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_ATTRIBUTES);
400 if (rc)
401 return rc;
402 range->attr = apei_exec_ctx_get_output(&ctx);
403
404 return 0;
405}
406
407static ssize_t __erst_get_record_count(void)
408{
409 struct apei_exec_context ctx;
410 int rc;
411
412 erst_exec_ctx_init(&ctx);
413 rc = apei_exec_run(&ctx, ACPI_ERST_GET_RECORD_COUNT);
414 if (rc)
415 return rc;
416 return apei_exec_ctx_get_output(&ctx);
417}
418
419ssize_t erst_get_record_count(void)
420{
421 ssize_t count;
422 unsigned long flags;
423
424 if (erst_disable)
425 return -ENODEV;
426
3b38bb5f 427 raw_spin_lock_irqsave(&erst_lock, flags);
a08f82d0 428 count = __erst_get_record_count();
3b38bb5f 429 raw_spin_unlock_irqrestore(&erst_lock, flags);
a08f82d0
HY		 430
431 return count;
432}
433EXPORT_SYMBOL_GPL(erst_get_record_count);
434
885b976f
HY		 435#define ERST_RECORD_ID_CACHE_SIZE_MIN 16
436#define ERST_RECORD_ID_CACHE_SIZE_MAX 1024
437
438struct erst_record_id_cache {
439 struct mutex lock;
440 u64 *entries;
441 int len;
442 int size;
443 int refcount;
444};
445
446static struct erst_record_id_cache erst_record_id_cache = {
447 .lock = __MUTEX_INITIALIZER(erst_record_id_cache.lock),
448 .refcount = 0,
449};
450
a08f82d0
HY		 451static int __erst_get_next_record_id(u64 *record_id)
452{
453 struct apei_exec_context ctx;
454 int rc;
455
456 erst_exec_ctx_init(&ctx);
457 rc = apei_exec_run(&ctx, ACPI_ERST_GET_RECORD_ID);
458 if (rc)
459 return rc;
460 *record_id = apei_exec_ctx_get_output(&ctx);
461
462 return 0;
463}
464
885b976f
HY		 465int erst_get_record_id_begin(int *pos)
466{
467 int rc;
468
469 if (erst_disable)
470 return -ENODEV;
471
472 rc = mutex_lock_interruptible(&erst_record_id_cache.lock);
473 if (rc)
474 return rc;
475 erst_record_id_cache.refcount++;
476 mutex_unlock(&erst_record_id_cache.lock);
477
478 *pos = 0;
479
480 return 0;
481}
482EXPORT_SYMBOL_GPL(erst_get_record_id_begin);
483
484/* erst_record_id_cache.lock must be held by caller */
485static int __erst_record_id_cache_add_one(void)
486{
487 u64 id, prev_id, first_id;
488 int i, rc;
489 u64 *entries;
490 unsigned long flags;
491
492 id = prev_id = first_id = APEI_ERST_INVALID_RECORD_ID;
493retry:
494 raw_spin_lock_irqsave(&erst_lock, flags);
495 rc = __erst_get_next_record_id(&id);
496 raw_spin_unlock_irqrestore(&erst_lock, flags);
497 if (rc == -ENOENT)
498 return 0;
499 if (rc)
500 return rc;
501 if (id == APEI_ERST_INVALID_RECORD_ID)
502 return 0;
503 /* can not skip current ID, or loop back to first ID */
504 if (id == prev_id || id == first_id)
505 return 0;
506 if (first_id == APEI_ERST_INVALID_RECORD_ID)
507 first_id = id;
508 prev_id = id;
509
510 entries = erst_record_id_cache.entries;
511 for (i = 0; i < erst_record_id_cache.len; i++) {
512 if (entries[i] == id)
513 break;
514 }
515 /* record id already in cache, try next */
516 if (i < erst_record_id_cache.len)
517 goto retry;
518 if (erst_record_id_cache.len >= erst_record_id_cache.size) {
519 int new_size, alloc_size;
520 u64 *new_entries;
521
522 new_size = erst_record_id_cache.size * 2;
523 new_size = clamp_val(new_size, ERST_RECORD_ID_CACHE_SIZE_MIN,
524 ERST_RECORD_ID_CACHE_SIZE_MAX);
525 if (new_size <= erst_record_id_cache.size) {
526 if (printk_ratelimit())
cb82a2e4 527 pr_warn(FW_WARN "too many record IDs!\n");
885b976f
HY		 528 return 0;
529 }
530 alloc_size = new_size * sizeof(entries[0]);
531 if (alloc_size < PAGE_SIZE)
532 new_entries = kmalloc(alloc_size, GFP_KERNEL);
533 else
534 new_entries = vmalloc(alloc_size);
535 if (!new_entries)
536 return -ENOMEM;
537 memcpy(new_entries, entries,
538 erst_record_id_cache.len * sizeof(entries[0]));
539 if (erst_record_id_cache.size < PAGE_SIZE)
540 kfree(entries);
541 else
542 vfree(entries);
543 erst_record_id_cache.entries = entries = new_entries;
544 erst_record_id_cache.size = new_size;
545 }
546 entries[i] = id;
547 erst_record_id_cache.len++;
548
549 return 1;
550}
551
a08f82d0
HY		 552/*
553 * Get the record ID of an existing error record on the persistent
554 * storage. If there is no error record on the persistent storage, the
555 * returned record_id is APEI_ERST_INVALID_RECORD_ID.
556 */
885b976f 557int erst_get_record_id_next(int *pos, u64 *record_id)
a08f82d0 558{
885b976f
HY		 559 int rc = 0;
560 u64 *entries;
a08f82d0
HY		 561
562 if (erst_disable)
563 return -ENODEV;
564
885b976f
HY		 565 /* must be enclosed by erst_get_record_id_begin/end */
566 BUG_ON(!erst_record_id_cache.refcount);
567 BUG_ON(*pos < 0 || *pos > erst_record_id_cache.len);
568
569 mutex_lock(&erst_record_id_cache.lock);
570 entries = erst_record_id_cache.entries;
571 for (; *pos < erst_record_id_cache.len; (*pos)++)
572 if (entries[*pos] != APEI_ERST_INVALID_RECORD_ID)
573 break;
574 /* found next record id in cache */
575 if (*pos < erst_record_id_cache.len) {
576 *record_id = entries[*pos];
577 (*pos)++;
578 goto out_unlock;
579 }
580
581 /* Try to add one more record ID to cache */
582 rc = __erst_record_id_cache_add_one();
583 if (rc < 0)
584 goto out_unlock;
585 /* successfully add one new ID */
586 if (rc == 1) {
587 *record_id = erst_record_id_cache.entries[*pos];
588 (*pos)++;
589 rc = 0;
590 } else {
591 *pos = -1;
592 *record_id = APEI_ERST_INVALID_RECORD_ID;
593 }
594out_unlock:
595 mutex_unlock(&erst_record_id_cache.lock);
a08f82d0
HY		 596
597 return rc;
598}
885b976f
HY		 599EXPORT_SYMBOL_GPL(erst_get_record_id_next);
600
601/* erst_record_id_cache.lock must be held by caller */
602static void __erst_record_id_cache_compact(void)
603{
604 int i, wpos = 0;
605 u64 *entries;
606
607 if (erst_record_id_cache.refcount)
608 return;
609
610 entries = erst_record_id_cache.entries;
611 for (i = 0; i < erst_record_id_cache.len; i++) {
612 if (entries[i] == APEI_ERST_INVALID_RECORD_ID)
613 continue;
614 if (wpos != i)
d3ab3edc 615 entries[wpos] = entries[i];
885b976f
HY		 616 wpos++;
617 }
618 erst_record_id_cache.len = wpos;
619}
620
621void erst_get_record_id_end(void)
622{
623 /*
624 * erst_disable != 0 should be detected by invoker via the
625 * return value of erst_get_record_id_begin/next, so this
626 * function should not be called for erst_disable != 0.
627 */
628 BUG_ON(erst_disable);
629
630 mutex_lock(&erst_record_id_cache.lock);
631 erst_record_id_cache.refcount--;
632 BUG_ON(erst_record_id_cache.refcount < 0);
633 __erst_record_id_cache_compact();
634 mutex_unlock(&erst_record_id_cache.lock);
635}
636EXPORT_SYMBOL_GPL(erst_get_record_id_end);
a08f82d0
HY		 637
638static int __erst_write_to_storage(u64 offset)
639{
640 struct apei_exec_context ctx;
641 u64 timeout = FIRMWARE_TIMEOUT;
642 u64 val;
643 int rc;
644
645 erst_exec_ctx_init(&ctx);
392913de 646 rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_WRITE);
a08f82d0
HY		 647 if (rc)
648 return rc;
649 apei_exec_ctx_set_input(&ctx, offset);
650 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_OFFSET);
651 if (rc)
652 return rc;
653 rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION);
654 if (rc)
655 return rc;
656 for (;;) {
657 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS);
658 if (rc)
659 return rc;
660 val = apei_exec_ctx_get_output(&ctx);
661 if (!val)
662 break;
663 if (erst_timedout(&timeout, SPIN_UNIT))
664 return -EIO;
665 }
666 rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS);
667 if (rc)
668 return rc;
669 val = apei_exec_ctx_get_output(&ctx);
392913de 670 rc = apei_exec_run_optional(&ctx, ACPI_ERST_END);
a08f82d0
HY		 671 if (rc)
672 return rc;
673
674 return erst_errno(val);
675}
676
677static int __erst_read_from_storage(u64 record_id, u64 offset)
678{
679 struct apei_exec_context ctx;
680 u64 timeout = FIRMWARE_TIMEOUT;
681 u64 val;
682 int rc;
683
684 erst_exec_ctx_init(&ctx);
392913de 685 rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_READ);
a08f82d0
HY		 686 if (rc)
687 return rc;
688 apei_exec_ctx_set_input(&ctx, offset);
689 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_OFFSET);
690 if (rc)
691 return rc;
692 apei_exec_ctx_set_input(&ctx, record_id);
693 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_ID);
694 if (rc)
695 return rc;
696 rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION);
697 if (rc)
698 return rc;
699 for (;;) {
700 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS);
701 if (rc)
702 return rc;
703 val = apei_exec_ctx_get_output(&ctx);
704 if (!val)
705 break;
706 if (erst_timedout(&timeout, SPIN_UNIT))
707 return -EIO;
708 };
709 rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS);
710 if (rc)
711 return rc;
712 val = apei_exec_ctx_get_output(&ctx);
392913de 713 rc = apei_exec_run_optional(&ctx, ACPI_ERST_END);
a08f82d0
HY		 714 if (rc)
715 return rc;
716
717 return erst_errno(val);
718}
719
720static int __erst_clear_from_storage(u64 record_id)
721{
722 struct apei_exec_context ctx;
723 u64 timeout = FIRMWARE_TIMEOUT;
724 u64 val;
725 int rc;
726
727 erst_exec_ctx_init(&ctx);
392913de 728 rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_CLEAR);
a08f82d0
HY		 729 if (rc)
730 return rc;
731 apei_exec_ctx_set_input(&ctx, record_id);
732 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_ID);
733 if (rc)
734 return rc;
735 rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION);
736 if (rc)
737 return rc;
738 for (;;) {
739 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS);
740 if (rc)
741 return rc;
742 val = apei_exec_ctx_get_output(&ctx);
743 if (!val)
744 break;
745 if (erst_timedout(&timeout, SPIN_UNIT))
746 return -EIO;
747 }
748 rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS);
749 if (rc)
750 return rc;
751 val = apei_exec_ctx_get_output(&ctx);
392913de 752 rc = apei_exec_run_optional(&ctx, ACPI_ERST_END);
a08f82d0
HY		 753 if (rc)
754 return rc;
755
756 return erst_errno(val);
757}
758
759/* NVRAM ERST Error Log Address Range is not supported yet */
760static void pr_unimpl_nvram(void)
761{
762 if (printk_ratelimit())
cb82a2e4 763 pr_warn("NVRAM ERST Log Address Range not implemented yet.\n");
a08f82d0
HY		 764}
765
766static int __erst_write_to_nvram(const struct cper_record_header *record)
767{
768 /* do not print message, because printk is not safe for NMI */
769 return -ENOSYS;
770}
771
772static int __erst_read_to_erange_from_nvram(u64 record_id, u64 *offset)
773{
774 pr_unimpl_nvram();
775 return -ENOSYS;
776}
777
778static int __erst_clear_from_nvram(u64 record_id)
779{
780 pr_unimpl_nvram();
781 return -ENOSYS;
782}
783
784int erst_write(const struct cper_record_header *record)
785{
786 int rc;
787 unsigned long flags;
788 struct cper_record_header *rcd_erange;
789
790 if (erst_disable)
791 return -ENODEV;
792
793 if (memcmp(record->signature, CPER_SIG_RECORD, CPER_SIG_SIZE))
794 return -EINVAL;
795
796 if (erst_erange.attr & ERST_RANGE_NVRAM) {
3b38bb5f 797 if (!raw_spin_trylock_irqsave(&erst_lock, flags))
a08f82d0
HY		 798 return -EBUSY;
799 rc = __erst_write_to_nvram(record);
3b38bb5f 800 raw_spin_unlock_irqrestore(&erst_lock, flags);
a08f82d0
HY		 801 return rc;
802 }
803
804 if (record->record_length > erst_erange.size)
805 return -EINVAL;
806
3b38bb5f 807 if (!raw_spin_trylock_irqsave(&erst_lock, flags))
a08f82d0
HY		 808 return -EBUSY;
809 memcpy(erst_erange.vaddr, record, record->record_length);
810 rcd_erange = erst_erange.vaddr;
811 /* signature for serialization system */
812 memcpy(&rcd_erange->persistence_information, "ER", 2);
813
814 rc = __erst_write_to_storage(0);
3b38bb5f 815 raw_spin_unlock_irqrestore(&erst_lock, flags);
a08f82d0
HY		 816
817 return rc;
818}
819EXPORT_SYMBOL_GPL(erst_write);
820
821static int __erst_read_to_erange(u64 record_id, u64 *offset)
822{
823 int rc;
824
825 if (erst_erange.attr & ERST_RANGE_NVRAM)
826 return __erst_read_to_erange_from_nvram(
827 record_id, offset);
828
829 rc = __erst_read_from_storage(record_id, 0);
830 if (rc)
831 return rc;
832 *offset = 0;
833
834 return 0;
835}
836
837static ssize_t __erst_read(u64 record_id, struct cper_record_header *record,
838 size_t buflen)
839{
840 int rc;
841 u64 offset, len = 0;
842 struct cper_record_header *rcd_tmp;
843
844 rc = __erst_read_to_erange(record_id, &offset);
845 if (rc)
846 return rc;
847 rcd_tmp = erst_erange.vaddr + offset;
848 len = rcd_tmp->record_length;
849 if (len <= buflen)
850 memcpy(record, rcd_tmp, len);
851
852 return len;
853}
854
855/*
856 * If return value > buflen, the buffer size is not big enough,
857 * else if return value < 0, something goes wrong,
858 * else everything is OK, and return value is record length
859 */
860ssize_t erst_read(u64 record_id, struct cper_record_header *record,
861 size_t buflen)
862{
863 ssize_t len;
864 unsigned long flags;
865
866 if (erst_disable)
867 return -ENODEV;
868
3b38bb5f 869 raw_spin_lock_irqsave(&erst_lock, flags);
a08f82d0 870 len = __erst_read(record_id, record, buflen);
3b38bb5f 871 raw_spin_unlock_irqrestore(&erst_lock, flags);
a08f82d0
HY		 872 return len;
873}
874EXPORT_SYMBOL_GPL(erst_read);
875
a08f82d0
HY		 876int erst_clear(u64 record_id)
877{
885b976f 878 int rc, i;
a08f82d0 879 unsigned long flags;
885b976f 880 u64 *entries;
a08f82d0
HY		 881
882 if (erst_disable)
883 return -ENODEV;
884
885b976f
HY		 885 rc = mutex_lock_interruptible(&erst_record_id_cache.lock);
886 if (rc)
887 return rc;
3b38bb5f 888 raw_spin_lock_irqsave(&erst_lock, flags);
a08f82d0
HY		 889 if (erst_erange.attr & ERST_RANGE_NVRAM)
890 rc = __erst_clear_from_nvram(record_id);
891 else
892 rc = __erst_clear_from_storage(record_id);
3b38bb5f 893 raw_spin_unlock_irqrestore(&erst_lock, flags);
885b976f
HY		 894 if (rc)
895 goto out;
896 entries = erst_record_id_cache.entries;
897 for (i = 0; i < erst_record_id_cache.len; i++) {
898 if (entries[i] == record_id)
899 entries[i] = APEI_ERST_INVALID_RECORD_ID;
900 }
901 __erst_record_id_cache_compact();
902out:
903 mutex_unlock(&erst_record_id_cache.lock);
a08f82d0
HY		 904 return rc;
905}
906EXPORT_SYMBOL_GPL(erst_clear);
907
908static int __init setup_erst_disable(char *str)
909{
910 erst_disable = 1;
911 return 0;
912}
913
914__setup("erst_disable", setup_erst_disable);
915
916static int erst_check_table(struct acpi_table_erst *erst_tab)
917{
3a78f965
HY		 918 if ((erst_tab->header_length !=
919 (sizeof(struct acpi_table_erst) - sizeof(erst_tab->header)))
7ed28f2e 920 && (erst_tab->header_length != sizeof(struct acpi_table_erst)))
a08f82d0
HY		 921 return -EINVAL;
922 if (erst_tab->header.length < sizeof(struct acpi_table_erst))
923 return -EINVAL;
924 if (erst_tab->entries !=
925 (erst_tab->header.length - sizeof(struct acpi_table_erst)) /
926 sizeof(struct acpi_erst_entry))
927 return -EINVAL;
928
929 return 0;
930}
931
06cf91b4
CG		 932static int erst_open_pstore(struct pstore_info *psi);
933static int erst_close_pstore(struct pstore_info *psi);
755d4fe4 934static ssize_t erst_reader(u64 *id, enum pstore_type_id *type, int *count,
f6f82851 935 struct timespec *time, char **buf,
9a4e1398 936 bool *compressed, struct pstore_info *psi);
3d6d8d20 937static int erst_writer(enum pstore_type_id type, enum kmsg_dump_reason reason,
b3b515bb 938 u64 *id, unsigned int part, int count, bool compressed,
b94fdd07 939 size_t size, struct pstore_info *psi);
755d4fe4 940static int erst_clearer(enum pstore_type_id type, u64 id, int count,
a9efd39c 941 struct timespec time, struct pstore_info *psi);
0bb77c46
TL		 942
943static struct pstore_info erst_info = {
944 .owner = THIS_MODULE,
945 .name = "erst",
df36ac1b 946 .flags = PSTORE_FLAGS_FRAGILE,
06cf91b4
CG		 947 .open = erst_open_pstore,
948 .close = erst_close_pstore,
0bb77c46
TL		 949 .read = erst_reader,
950 .write = erst_writer,
638c1fd3 951 .erase = erst_clearer
0bb77c46
TL		 952};
953
954#define CPER_CREATOR_PSTORE \
955 UUID_LE(0x75a574e3, 0x5052, 0x4b29, 0x8a, 0x8e, 0xbe, 0x2c, \
956 0x64, 0x90, 0xb8, 0x9d)
957#define CPER_SECTION_TYPE_DMESG \
958 UUID_LE(0xc197e04e, 0xd545, 0x4a70, 0x9c, 0x17, 0xa5, 0x54, \
959 0x94, 0x19, 0xeb, 0x12)
901037ba
AB		 960#define CPER_SECTION_TYPE_DMESG_Z \
961 UUID_LE(0x4f118707, 0x04dd, 0x4055, 0xb5, 0xdd, 0x95, 0x6d, \
962 0x34, 0xdd, 0xfa, 0xc6)
0bb77c46
TL		 963#define CPER_SECTION_TYPE_MCE \
964 UUID_LE(0xfe08ffbe, 0x95e4, 0x4be7, 0xbc, 0x73, 0x40, 0x96, \
965 0x04, 0x4a, 0x38, 0xfc)
966
967struct cper_pstore_record {
968 struct cper_record_header hdr;
969 struct cper_section_descriptor sec_hdr;
970 char data[];
971} __packed;
972
06cf91b4
CG		 973static int reader_pos;
974
975static int erst_open_pstore(struct pstore_info *psi)
976{
977 int rc;
978
979 if (erst_disable)
980 return -ENODEV;
981
982 rc = erst_get_record_id_begin(&reader_pos);
983
984 return rc;
985}
986
987static int erst_close_pstore(struct pstore_info *psi)
988{
989 erst_get_record_id_end();
990
991 return 0;
992}
993
755d4fe4 994static ssize_t erst_reader(u64 *id, enum pstore_type_id *type, int *count,
f6f82851 995 struct timespec *time, char **buf,
9a4e1398 996 bool *compressed, struct pstore_info *psi)
0bb77c46
TL		 997{
998 int rc;
06cf91b4 999 ssize_t len = 0;
0bb77c46 1000 u64 record_id;
f6f82851
KC		 1001 struct cper_pstore_record *rcd;
1002 size_t rcd_len = sizeof(*rcd) + erst_info.bufsize;
0bb77c46
TL		 1003
1004 if (erst_disable)
1005 return -ENODEV;
1006
f6f82851
KC		 1007 rcd = kmalloc(rcd_len, GFP_KERNEL);
1008 if (!rcd) {
1009 rc = -ENOMEM;
1010 goto out;
1011 }
0bb77c46 1012skip:
06cf91b4
CG		 1013 rc = erst_get_record_id_next(&reader_pos, &record_id);
1014 if (rc)
1015 goto out;
1016
0bb77c46
TL		 1017 /* no more record */
1018 if (record_id == APEI_ERST_INVALID_RECORD_ID) {
f6f82851 1019 rc = -EINVAL;
06cf91b4 1020 goto out;
0bb77c46
TL		 1021 }
1022
f6f82851 1023 len = erst_read(record_id, &rcd->hdr, rcd_len);
f5ec25de
CG		 1024 /* The record may be cleared by others, try read next record */
1025 if (len == -ENOENT)
1026 goto skip;
f6f82851
KC		 1027 else if (len < sizeof(*rcd)) {
1028 rc = -EIO;
f5ec25de
CG		 1029 goto out;
1030 }
0bb77c46
TL		 1031 if (uuid_le_cmp(rcd->hdr.creator_id, CPER_CREATOR_PSTORE) != 0)
1032 goto skip;
0bb77c46 1033
f6f82851
KC		 1034 *buf = kmalloc(len, GFP_KERNEL);
1035 if (*buf == NULL) {
1036 rc = -ENOMEM;
1037 goto out;
1038 }
1039 memcpy(*buf, rcd->data, len - sizeof(*rcd));
0bb77c46 1040 *id = record_id;
901037ba 1041 *compressed = false;
0bb77c46 1042 if (uuid_le_cmp(rcd->sec_hdr.section_type,
901037ba
AB		 1043 CPER_SECTION_TYPE_DMESG_Z) == 0) {
1044 *type = PSTORE_TYPE_DMESG;
1045 *compressed = true;
1046 } else if (uuid_le_cmp(rcd->sec_hdr.section_type,
0bb77c46
TL		 1047 CPER_SECTION_TYPE_DMESG) == 0)
1048 *type = PSTORE_TYPE_DMESG;
1049 else if (uuid_le_cmp(rcd->sec_hdr.section_type,
1050 CPER_SECTION_TYPE_MCE) == 0)
1051 *type = PSTORE_TYPE_MCE;
1052 else
1053 *type = PSTORE_TYPE_UNKNOWN;
1054
1055 if (rcd->hdr.validation_bits & CPER_VALID_TIMESTAMP)
1056 time->tv_sec = rcd->hdr.timestamp;
1057 else
1058 time->tv_sec = 0;
1059 time->tv_nsec = 0;
1060
06cf91b4 1061out:
f6f82851 1062 kfree(rcd);
06cf91b4 1063 return (rc < 0) ? rc : (len - sizeof(*rcd));
0bb77c46
TL		 1064}
1065
3d6d8d20 1066static int erst_writer(enum pstore_type_id type, enum kmsg_dump_reason reason,
b3b515bb 1067 u64 *id, unsigned int part, int count, bool compressed,
b94fdd07 1068 size_t size, struct pstore_info *psi)
0bb77c46
TL		 1069{
1070 struct cper_pstore_record *rcd = (struct cper_pstore_record *)
1071 (erst_info.buf - sizeof(*rcd));
b238b8fa 1072 int ret;
0bb77c46
TL		 1073
1074 memset(rcd, 0, sizeof(*rcd));
1075 memcpy(rcd->hdr.signature, CPER_SIG_RECORD, CPER_SIG_SIZE);
1076 rcd->hdr.revision = CPER_RECORD_REV;
1077 rcd->hdr.signature_end = CPER_SIG_END;
1078 rcd->hdr.section_count = 1;
1079 rcd->hdr.error_severity = CPER_SEV_FATAL;
1080 /* timestamp valid. platform_id, partition_id are invalid */
1081 rcd->hdr.validation_bits = CPER_VALID_TIMESTAMP;
1082 rcd->hdr.timestamp = get_seconds();
1083 rcd->hdr.record_length = sizeof(*rcd) + size;
1084 rcd->hdr.creator_id = CPER_CREATOR_PSTORE;
1085 rcd->hdr.notification_type = CPER_NOTIFY_MCE;
1086 rcd->hdr.record_id = cper_next_record_id();
1087 rcd->hdr.flags = CPER_HW_ERROR_FLAGS_PREVERR;
1088
1089 rcd->sec_hdr.section_offset = sizeof(*rcd);
1090 rcd->sec_hdr.section_length = size;
1091 rcd->sec_hdr.revision = CPER_SEC_REV;
1092 /* fru_id and fru_text is invalid */
1093 rcd->sec_hdr.validation_bits = 0;
1094 rcd->sec_hdr.flags = CPER_SEC_PRIMARY;
1095 switch (type) {
1096 case PSTORE_TYPE_DMESG:
901037ba
AB		 1097 if (compressed)
1098 rcd->sec_hdr.section_type = CPER_SECTION_TYPE_DMESG_Z;
1099 else
1100 rcd->sec_hdr.section_type = CPER_SECTION_TYPE_DMESG;
0bb77c46
TL		 1101 break;
1102 case PSTORE_TYPE_MCE:
1103 rcd->sec_hdr.section_type = CPER_SECTION_TYPE_MCE;
1104 break;
1105 default:
1106 return -EINVAL;
1107 }
1108 rcd->sec_hdr.section_severity = CPER_SEV_FATAL;
1109
b238b8fa
CG		 1110 ret = erst_write(&rcd->hdr);
1111 *id = rcd->hdr.record_id;
0bb77c46 1112
b238b8fa 1113 return ret;
0bb77c46
TL		 1114}
1115
755d4fe4 1116static int erst_clearer(enum pstore_type_id type, u64 id, int count,
a9efd39c 1117 struct timespec time, struct pstore_info *psi)
638c1fd3
MG		 1118{
1119 return erst_clear(id);
1120}
1121
a08f82d0
HY		 1122static int __init erst_init(void)
1123{
1124 int rc = 0;
1125 acpi_status status;
1126 struct apei_exec_context ctx;
1127 struct apei_resources erst_resources;
1128 struct resource *r;
0bb77c46 1129 char *buf;
a08f82d0
HY		 1130
1131 if (acpi_disabled)
1132 goto err;
1133
1134 if (erst_disable) {
cb82a2e4 1135 pr_info(
a08f82d0
HY		 1136 "Error Record Serialization Table (ERST) support is disabled.\n");
1137 goto err;
1138 }
1139
1140 status = acpi_get_table(ACPI_SIG_ERST, 0,
1141 (struct acpi_table_header **)&erst_tab);
ad686154 1142 if (status == AE_NOT_FOUND)
a08f82d0 1143 goto err;
ad686154 1144 else if (ACPI_FAILURE(status)) {
a08f82d0 1145 const char *msg = acpi_format_exception(status);
cb82a2e4 1146 pr_err("Failed to get table, %s\n", msg);
a08f82d0
HY		 1147 rc = -EINVAL;
1148 goto err;
1149 }
1150
1151 rc = erst_check_table(erst_tab);
1152 if (rc) {
cb82a2e4 1153 pr_err(FW_BUG "ERST table is invalid.\n");
a08f82d0
HY		 1154 goto err;
1155 }
1156
1157 apei_resources_init(&erst_resources);
1158 erst_exec_ctx_init(&ctx);
1159 rc = apei_exec_collect_resources(&ctx, &erst_resources);
1160 if (rc)
1161 goto err_fini;
1162 rc = apei_resources_request(&erst_resources, "APEI ERST");
1163 if (rc)
1164 goto err_fini;
1165 rc = apei_exec_pre_map_gars(&ctx);
1166 if (rc)
1167 goto err_release;
1168 rc = erst_get_erange(&erst_erange);
1169 if (rc) {
1170 if (rc == -ENODEV)
cb82a2e4 1171 pr_info(
a08f82d0
HY		 1172 "The corresponding hardware device or firmware implementation "
1173 "is not available.\n");
1174 else
cb82a2e4 1175 pr_err("Failed to get Error Log Address Range.\n");
a08f82d0
HY		 1176 goto err_unmap_reg;
1177 }
1178
1179 r = request_mem_region(erst_erange.base, erst_erange.size, "APEI ERST");
1180 if (!r) {
cb82a2e4
BP		 1181 pr_err("Can not request [mem %#010llx-%#010llx] for ERST.\n",
1182 (unsigned long long)erst_erange.base,
1183 (unsigned long long)erst_erange.base + erst_erange.size - 1);
a08f82d0
HY		 1184 rc = -EIO;
1185 goto err_unmap_reg;
1186 }
1187 rc = -ENOMEM;
1188 erst_erange.vaddr = ioremap_cache(erst_erange.base,
1189 erst_erange.size);
1190 if (!erst_erange.vaddr)
1191 goto err_release_erange;
1192
cb82a2e4 1193 pr_info(
74fd6c6f
LS		 1194 "Error Record Serialization Table (ERST) support is initialized.\n");
1195
0bb77c46 1196 buf = kmalloc(erst_erange.size, GFP_KERNEL);
abd4d558 1197 spin_lock_init(&erst_info.buf_lock);
0bb77c46
TL		 1198 if (buf) {
1199 erst_info.buf = buf + sizeof(struct cper_pstore_record);
1200 erst_info.bufsize = erst_erange.size -
1201 sizeof(struct cper_pstore_record);
74fd6c6f
LS		 1202 rc = pstore_register(&erst_info);
1203 if (rc) {
1204 if (rc != -EPERM)
cb82a2e4
BP		 1205 pr_info(
1206 "Could not register with persistent store.\n");
74fd6c6f
LS		 1207 erst_info.buf = NULL;
1208 erst_info.bufsize = 0;
0bb77c46
TL		 1209 kfree(buf);
1210 }
74fd6c6f 1211 } else
cb82a2e4
BP		 1212 pr_err(
1213 "Failed to allocate %lld bytes for persistent store error log.\n",
74fd6c6f 1214 erst_erange.size);
a08f82d0
HY		 1215
1216 return 0;
1217
1218err_release_erange:
1219 release_mem_region(erst_erange.base, erst_erange.size);
1220err_unmap_reg:
1221 apei_exec_post_unmap_gars(&ctx);
1222err_release:
1223 apei_resources_release(&erst_resources);
1224err_fini:
1225 apei_resources_fini(&erst_resources);
1226err:
1227 erst_disable = 1;
1228 return rc;
1229}
1230
1231device_initcall(erst_init);
Linux kernel - Deliverables
This page took 0.525672 seconds and 5 git commands to generate.