2 * APEI Error Record Serialization Table support
4 * ERST is a way provided by APEI to save and retrieve hardware error
5 * information to and from a persistent store.
7 * For more information about ERST, please refer to ACPI Specification
8 * version 4.0, section 17.4.
10 * Copyright 2010 Intel Corp.
11 * Author: Huang Ying <ying.huang@intel.com>
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.
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.
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
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/init.h>
30 #include <linux/delay.h>
32 #include <linux/acpi.h>
33 #include <linux/uaccess.h>
34 #include <linux/cper.h>
35 #include <linux/nmi.h>
36 #include <linux/hardirq.h>
37 #include <linux/pstore.h>
38 #include <linux/vmalloc.h>
39 #include <acpi/apei.h>
41 #include "apei-internal.h"
44 #define pr_fmt(fmt) "ERST: " fmt
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
54 #define ERST_TAB_ENTRY(tab) \
55 ((struct acpi_whea_header *)((char *)(tab) + \
56 sizeof(struct acpi_table_erst)))
58 #define SPIN_UNIT 100 /* 100ns */
59 /* Firmware should respond within 1 milliseconds */
60 #define FIRMWARE_TIMEOUT (1 * NSEC_PER_MSEC)
61 #define FIRMWARE_MAX_STALL 50 /* 50us */
64 EXPORT_SYMBOL_GPL(erst_disable);
66 static struct acpi_table_erst *erst_tab;
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
74 * ERST Error Log Address Range, used as buffer for reading/writing
77 static struct erst_erange {
85 * Prevent ERST interpreter to run simultaneously, because the
86 * corresponding firmware implementation may not work properly when
87 * invoked simultaneously.
89 * It is used to provide exclusive accessing for ERST Error Log
92 static DEFINE_RAW_SPINLOCK(erst_lock);
94 static inline int erst_errno(int command_status)
96 switch (command_status) {
97 case ERST_STATUS_SUCCESS:
99 case ERST_STATUS_HARDWARE_NOT_AVAILABLE:
101 case ERST_STATUS_NOT_ENOUGH_SPACE:
103 case ERST_STATUS_RECORD_STORE_EMPTY:
104 case ERST_STATUS_RECORD_NOT_FOUND:
111 static int erst_timedout(u64 *t, u64 spin_unit)
113 if ((s64)*t < spin_unit) {
114 pr_warn(FW_WARN "Firmware does not respond in time.\n");
119 touch_nmi_watchdog();
123 static int erst_exec_load_var1(struct apei_exec_context *ctx,
124 struct acpi_whea_header *entry)
126 return __apei_exec_read_register(entry, &ctx->var1);
129 static int erst_exec_load_var2(struct apei_exec_context *ctx,
130 struct acpi_whea_header *entry)
132 return __apei_exec_read_register(entry, &ctx->var2);
135 static int erst_exec_store_var1(struct apei_exec_context *ctx,
136 struct acpi_whea_header *entry)
138 return __apei_exec_write_register(entry, ctx->var1);
141 static int erst_exec_add(struct apei_exec_context *ctx,
142 struct acpi_whea_header *entry)
144 ctx->var1 += ctx->var2;
148 static int erst_exec_subtract(struct apei_exec_context *ctx,
149 struct acpi_whea_header *entry)
151 ctx->var1 -= ctx->var2;
155 static int erst_exec_add_value(struct apei_exec_context *ctx,
156 struct acpi_whea_header *entry)
161 rc = __apei_exec_read_register(entry, &val);
165 rc = __apei_exec_write_register(entry, val);
169 static int erst_exec_subtract_value(struct apei_exec_context *ctx,
170 struct acpi_whea_header *entry)
175 rc = __apei_exec_read_register(entry, &val);
179 rc = __apei_exec_write_register(entry, val);
183 static int erst_exec_stall(struct apei_exec_context *ctx,
184 struct acpi_whea_header *entry)
188 if (ctx->value > FIRMWARE_MAX_STALL) {
191 "Too long stall time for stall instruction: 0x%llx.\n",
193 stall_time = FIRMWARE_MAX_STALL;
195 stall_time = ctx->value;
200 static int erst_exec_stall_while_true(struct apei_exec_context *ctx,
201 struct acpi_whea_header *entry)
205 u64 timeout = FIRMWARE_TIMEOUT;
208 if (ctx->var1 > FIRMWARE_MAX_STALL) {
211 "Too long stall time for stall while true instruction: 0x%llx.\n",
213 stall_time = FIRMWARE_MAX_STALL;
215 stall_time = ctx->var1;
218 rc = __apei_exec_read_register(entry, &val);
221 if (val != ctx->value)
223 if (erst_timedout(&timeout, stall_time * NSEC_PER_USEC))
229 static int erst_exec_skip_next_instruction_if_true(
230 struct apei_exec_context *ctx,
231 struct acpi_whea_header *entry)
236 rc = __apei_exec_read_register(entry, &val);
239 if (val == ctx->value) {
241 return APEI_EXEC_SET_IP;
247 static int erst_exec_goto(struct apei_exec_context *ctx,
248 struct acpi_whea_header *entry)
250 ctx->ip = ctx->value;
251 return APEI_EXEC_SET_IP;
254 static int erst_exec_set_src_address_base(struct apei_exec_context *ctx,
255 struct acpi_whea_header *entry)
257 return __apei_exec_read_register(entry, &ctx->src_base);
260 static int erst_exec_set_dst_address_base(struct apei_exec_context *ctx,
261 struct acpi_whea_header *entry)
263 return __apei_exec_read_register(entry, &ctx->dst_base);
266 static int erst_exec_move_data(struct apei_exec_context *ctx,
267 struct acpi_whea_header *entry)
273 /* ioremap does not work in interrupt context */
274 if (in_interrupt()) {
275 pr_warn("MOVE_DATA can not be used in interrupt context.\n");
279 rc = __apei_exec_read_register(entry, &offset);
283 src = ioremap(ctx->src_base + offset, ctx->var2);
286 dst = ioremap(ctx->dst_base + offset, ctx->var2);
292 memmove(dst, src, ctx->var2);
300 static 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,
305 [ACPI_ERST_READ_REGISTER_VALUE] = {
306 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
307 .run = apei_exec_read_register_value,
309 [ACPI_ERST_WRITE_REGISTER] = {
310 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
311 .run = apei_exec_write_register,
313 [ACPI_ERST_WRITE_REGISTER_VALUE] = {
314 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
315 .run = apei_exec_write_register_value,
319 .run = apei_exec_noop,
321 [ACPI_ERST_LOAD_VAR1] = {
322 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
323 .run = erst_exec_load_var1,
325 [ACPI_ERST_LOAD_VAR2] = {
326 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
327 .run = erst_exec_load_var2,
329 [ACPI_ERST_STORE_VAR1] = {
330 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
331 .run = erst_exec_store_var1,
335 .run = erst_exec_add,
337 [ACPI_ERST_SUBTRACT] = {
339 .run = erst_exec_subtract,
341 [ACPI_ERST_ADD_VALUE] = {
342 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
343 .run = erst_exec_add_value,
345 [ACPI_ERST_SUBTRACT_VALUE] = {
346 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
347 .run = erst_exec_subtract_value,
349 [ACPI_ERST_STALL] = {
351 .run = erst_exec_stall,
353 [ACPI_ERST_STALL_WHILE_TRUE] = {
354 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
355 .run = erst_exec_stall_while_true,
357 [ACPI_ERST_SKIP_NEXT_IF_TRUE] = {
358 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
359 .run = erst_exec_skip_next_instruction_if_true,
363 .run = erst_exec_goto,
365 [ACPI_ERST_SET_SRC_ADDRESS_BASE] = {
366 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
367 .run = erst_exec_set_src_address_base,
369 [ACPI_ERST_SET_DST_ADDRESS_BASE] = {
370 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
371 .run = erst_exec_set_dst_address_base,
373 [ACPI_ERST_MOVE_DATA] = {
374 .flags = APEI_EXEC_INS_ACCESS_REGISTER,
375 .run = erst_exec_move_data,
379 static inline void erst_exec_ctx_init(struct apei_exec_context *ctx)
381 apei_exec_ctx_init(ctx, erst_ins_type, ARRAY_SIZE(erst_ins_type),
382 ERST_TAB_ENTRY(erst_tab), erst_tab->entries);
385 static int erst_get_erange(struct erst_erange *range)
387 struct apei_exec_context ctx;
390 erst_exec_ctx_init(&ctx);
391 rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_RANGE);
394 range->base = apei_exec_ctx_get_output(&ctx);
395 rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_LENGTH);
398 range->size = apei_exec_ctx_get_output(&ctx);
399 rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_ATTRIBUTES);
402 range->attr = apei_exec_ctx_get_output(&ctx);
407 static ssize_t __erst_get_record_count(void)
409 struct apei_exec_context ctx;
412 erst_exec_ctx_init(&ctx);
413 rc = apei_exec_run(&ctx, ACPI_ERST_GET_RECORD_COUNT);
416 return apei_exec_ctx_get_output(&ctx);
419 ssize_t erst_get_record_count(void)
427 raw_spin_lock_irqsave(&erst_lock, flags);
428 count = __erst_get_record_count();
429 raw_spin_unlock_irqrestore(&erst_lock, flags);
433 EXPORT_SYMBOL_GPL(erst_get_record_count);
435 #define ERST_RECORD_ID_CACHE_SIZE_MIN 16
436 #define ERST_RECORD_ID_CACHE_SIZE_MAX 1024
438 struct erst_record_id_cache {
446 static struct erst_record_id_cache erst_record_id_cache = {
447 .lock = __MUTEX_INITIALIZER(erst_record_id_cache.lock),
451 static int __erst_get_next_record_id(u64 *record_id)
453 struct apei_exec_context ctx;
456 erst_exec_ctx_init(&ctx);
457 rc = apei_exec_run(&ctx, ACPI_ERST_GET_RECORD_ID);
460 *record_id = apei_exec_ctx_get_output(&ctx);
465 int erst_get_record_id_begin(int *pos)
472 rc = mutex_lock_interruptible(&erst_record_id_cache.lock);
475 erst_record_id_cache.refcount++;
476 mutex_unlock(&erst_record_id_cache.lock);
482 EXPORT_SYMBOL_GPL(erst_get_record_id_begin);
484 /* erst_record_id_cache.lock must be held by caller */
485 static int __erst_record_id_cache_add_one(void)
487 u64 id, prev_id, first_id;
492 id = prev_id = first_id = APEI_ERST_INVALID_RECORD_ID;
494 raw_spin_lock_irqsave(&erst_lock, flags);
495 rc = __erst_get_next_record_id(&id);
496 raw_spin_unlock_irqrestore(&erst_lock, flags);
501 if (id == APEI_ERST_INVALID_RECORD_ID)
503 /* can not skip current ID, or loop back to first ID */
504 if (id == prev_id || id == first_id)
506 if (first_id == APEI_ERST_INVALID_RECORD_ID)
510 entries = erst_record_id_cache.entries;
511 for (i = 0; i < erst_record_id_cache.len; i++) {
512 if (entries[i] == id)
515 /* record id already in cache, try next */
516 if (i < erst_record_id_cache.len)
518 if (erst_record_id_cache.len >= erst_record_id_cache.size) {
519 int new_size, alloc_size;
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())
527 pr_warn(FW_WARN "too many record IDs!\n");
530 alloc_size = new_size * sizeof(entries[0]);
531 if (alloc_size < PAGE_SIZE)
532 new_entries = kmalloc(alloc_size, GFP_KERNEL);
534 new_entries = vmalloc(alloc_size);
537 memcpy(new_entries, entries,
538 erst_record_id_cache.len * sizeof(entries[0]));
539 if (erst_record_id_cache.size < PAGE_SIZE)
543 erst_record_id_cache.entries = entries = new_entries;
544 erst_record_id_cache.size = new_size;
547 erst_record_id_cache.len++;
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.
557 int erst_get_record_id_next(int *pos, u64 *record_id)
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);
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)
574 /* found next record id in cache */
575 if (*pos < erst_record_id_cache.len) {
576 *record_id = entries[*pos];
581 /* Try to add one more record ID to cache */
582 rc = __erst_record_id_cache_add_one();
585 /* successfully add one new ID */
587 *record_id = erst_record_id_cache.entries[*pos];
592 *record_id = APEI_ERST_INVALID_RECORD_ID;
595 mutex_unlock(&erst_record_id_cache.lock);
599 EXPORT_SYMBOL_GPL(erst_get_record_id_next);
601 /* erst_record_id_cache.lock must be held by caller */
602 static void __erst_record_id_cache_compact(void)
607 if (erst_record_id_cache.refcount)
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)
615 entries[wpos] = entries[i];
618 erst_record_id_cache.len = wpos;
621 void erst_get_record_id_end(void)
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.
628 BUG_ON(erst_disable);
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);
636 EXPORT_SYMBOL_GPL(erst_get_record_id_end);
638 static int __erst_write_to_storage(u64 offset)
640 struct apei_exec_context ctx;
641 u64 timeout = FIRMWARE_TIMEOUT;
645 erst_exec_ctx_init(&ctx);
646 rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_WRITE);
649 apei_exec_ctx_set_input(&ctx, offset);
650 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_OFFSET);
653 rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION);
657 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS);
660 val = apei_exec_ctx_get_output(&ctx);
663 if (erst_timedout(&timeout, SPIN_UNIT))
666 rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS);
669 val = apei_exec_ctx_get_output(&ctx);
670 rc = apei_exec_run_optional(&ctx, ACPI_ERST_END);
674 return erst_errno(val);
677 static int __erst_read_from_storage(u64 record_id, u64 offset)
679 struct apei_exec_context ctx;
680 u64 timeout = FIRMWARE_TIMEOUT;
684 erst_exec_ctx_init(&ctx);
685 rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_READ);
688 apei_exec_ctx_set_input(&ctx, offset);
689 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_OFFSET);
692 apei_exec_ctx_set_input(&ctx, record_id);
693 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_ID);
696 rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION);
700 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS);
703 val = apei_exec_ctx_get_output(&ctx);
706 if (erst_timedout(&timeout, SPIN_UNIT))
709 rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS);
712 val = apei_exec_ctx_get_output(&ctx);
713 rc = apei_exec_run_optional(&ctx, ACPI_ERST_END);
717 return erst_errno(val);
720 static int __erst_clear_from_storage(u64 record_id)
722 struct apei_exec_context ctx;
723 u64 timeout = FIRMWARE_TIMEOUT;
727 erst_exec_ctx_init(&ctx);
728 rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_CLEAR);
731 apei_exec_ctx_set_input(&ctx, record_id);
732 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_ID);
735 rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION);
739 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS);
742 val = apei_exec_ctx_get_output(&ctx);
745 if (erst_timedout(&timeout, SPIN_UNIT))
748 rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS);
751 val = apei_exec_ctx_get_output(&ctx);
752 rc = apei_exec_run_optional(&ctx, ACPI_ERST_END);
756 return erst_errno(val);
759 /* NVRAM ERST Error Log Address Range is not supported yet */
760 static void pr_unimpl_nvram(void)
762 if (printk_ratelimit())
763 pr_warn("NVRAM ERST Log Address Range not implemented yet.\n");
766 static int __erst_write_to_nvram(const struct cper_record_header *record)
768 /* do not print message, because printk is not safe for NMI */
772 static int __erst_read_to_erange_from_nvram(u64 record_id, u64 *offset)
778 static int __erst_clear_from_nvram(u64 record_id)
784 int erst_write(const struct cper_record_header *record)
788 struct cper_record_header *rcd_erange;
793 if (memcmp(record->signature, CPER_SIG_RECORD, CPER_SIG_SIZE))
796 if (erst_erange.attr & ERST_RANGE_NVRAM) {
797 if (!raw_spin_trylock_irqsave(&erst_lock, flags))
799 rc = __erst_write_to_nvram(record);
800 raw_spin_unlock_irqrestore(&erst_lock, flags);
804 if (record->record_length > erst_erange.size)
807 if (!raw_spin_trylock_irqsave(&erst_lock, flags))
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);
814 rc = __erst_write_to_storage(0);
815 raw_spin_unlock_irqrestore(&erst_lock, flags);
819 EXPORT_SYMBOL_GPL(erst_write);
821 static int __erst_read_to_erange(u64 record_id, u64 *offset)
825 if (erst_erange.attr & ERST_RANGE_NVRAM)
826 return __erst_read_to_erange_from_nvram(
829 rc = __erst_read_from_storage(record_id, 0);
837 static ssize_t __erst_read(u64 record_id, struct cper_record_header *record,
842 struct cper_record_header *rcd_tmp;
844 rc = __erst_read_to_erange(record_id, &offset);
847 rcd_tmp = erst_erange.vaddr + offset;
848 len = rcd_tmp->record_length;
850 memcpy(record, rcd_tmp, len);
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
860 ssize_t erst_read(u64 record_id, struct cper_record_header *record,
869 raw_spin_lock_irqsave(&erst_lock, flags);
870 len = __erst_read(record_id, record, buflen);
871 raw_spin_unlock_irqrestore(&erst_lock, flags);
874 EXPORT_SYMBOL_GPL(erst_read);
876 int erst_clear(u64 record_id)
885 rc = mutex_lock_interruptible(&erst_record_id_cache.lock);
888 raw_spin_lock_irqsave(&erst_lock, flags);
889 if (erst_erange.attr & ERST_RANGE_NVRAM)
890 rc = __erst_clear_from_nvram(record_id);
892 rc = __erst_clear_from_storage(record_id);
893 raw_spin_unlock_irqrestore(&erst_lock, flags);
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;
901 __erst_record_id_cache_compact();
903 mutex_unlock(&erst_record_id_cache.lock);
906 EXPORT_SYMBOL_GPL(erst_clear);
908 static int __init setup_erst_disable(char *str)
914 __setup("erst_disable", setup_erst_disable);
916 static int erst_check_table(struct acpi_table_erst *erst_tab)
918 if ((erst_tab->header_length !=
919 (sizeof(struct acpi_table_erst) - sizeof(erst_tab->header)))
920 && (erst_tab->header_length != sizeof(struct acpi_table_erst)))
922 if (erst_tab->header.length < sizeof(struct acpi_table_erst))
924 if (erst_tab->entries !=
925 (erst_tab->header.length - sizeof(struct acpi_table_erst)) /
926 sizeof(struct acpi_erst_entry))
932 static int erst_open_pstore(struct pstore_info *psi);
933 static int erst_close_pstore(struct pstore_info *psi);
934 static ssize_t erst_reader(u64 *id, enum pstore_type_id *type, int *count,
935 struct timespec *time, char **buf,
936 bool *compressed, struct pstore_info *psi);
937 static int erst_writer(enum pstore_type_id type, enum kmsg_dump_reason reason,
938 u64 *id, unsigned int part, int count, bool compressed,
939 size_t size, struct pstore_info *psi);
940 static int erst_clearer(enum pstore_type_id type, u64 id, int count,
941 struct timespec time, struct pstore_info *psi);
943 static struct pstore_info erst_info = {
944 .owner = THIS_MODULE,
946 .flags = PSTORE_FLAGS_FRAGILE,
947 .open = erst_open_pstore,
948 .close = erst_close_pstore,
950 .write = erst_writer,
951 .erase = erst_clearer
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)
960 #define CPER_SECTION_TYPE_DMESG_Z \
961 UUID_LE(0x4f118707, 0x04dd, 0x4055, 0xb5, 0xdd, 0x95, 0x6d, \
962 0x34, 0xdd, 0xfa, 0xc6)
963 #define CPER_SECTION_TYPE_MCE \
964 UUID_LE(0xfe08ffbe, 0x95e4, 0x4be7, 0xbc, 0x73, 0x40, 0x96, \
965 0x04, 0x4a, 0x38, 0xfc)
967 struct cper_pstore_record {
968 struct cper_record_header hdr;
969 struct cper_section_descriptor sec_hdr;
973 static int reader_pos;
975 static int erst_open_pstore(struct pstore_info *psi)
982 rc = erst_get_record_id_begin(&reader_pos);
987 static int erst_close_pstore(struct pstore_info *psi)
989 erst_get_record_id_end();
994 static ssize_t erst_reader(u64 *id, enum pstore_type_id *type, int *count,
995 struct timespec *time, char **buf,
996 bool *compressed, struct pstore_info *psi)
1001 struct cper_pstore_record *rcd;
1002 size_t rcd_len = sizeof(*rcd) + erst_info.bufsize;
1007 rcd = kmalloc(rcd_len, GFP_KERNEL);
1013 rc = erst_get_record_id_next(&reader_pos, &record_id);
1017 /* no more record */
1018 if (record_id == APEI_ERST_INVALID_RECORD_ID) {
1023 len = erst_read(record_id, &rcd->hdr, rcd_len);
1024 /* The record may be cleared by others, try read next record */
1027 else if (len < sizeof(*rcd)) {
1031 if (uuid_le_cmp(rcd->hdr.creator_id, CPER_CREATOR_PSTORE) != 0)
1034 *buf = kmalloc(len, GFP_KERNEL);
1039 memcpy(*buf, rcd->data, len - sizeof(*rcd));
1041 *compressed = false;
1042 if (uuid_le_cmp(rcd->sec_hdr.section_type,
1043 CPER_SECTION_TYPE_DMESG_Z) == 0) {
1044 *type = PSTORE_TYPE_DMESG;
1046 } else if (uuid_le_cmp(rcd->sec_hdr.section_type,
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;
1053 *type = PSTORE_TYPE_UNKNOWN;
1055 if (rcd->hdr.validation_bits & CPER_VALID_TIMESTAMP)
1056 time->tv_sec = rcd->hdr.timestamp;
1063 return (rc < 0) ? rc : (len - sizeof(*rcd));
1066 static int erst_writer(enum pstore_type_id type, enum kmsg_dump_reason reason,
1067 u64 *id, unsigned int part, int count, bool compressed,
1068 size_t size, struct pstore_info *psi)
1070 struct cper_pstore_record *rcd = (struct cper_pstore_record *)
1071 (erst_info.buf - sizeof(*rcd));
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;
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;
1096 case PSTORE_TYPE_DMESG:
1098 rcd->sec_hdr.section_type = CPER_SECTION_TYPE_DMESG_Z;
1100 rcd->sec_hdr.section_type = CPER_SECTION_TYPE_DMESG;
1102 case PSTORE_TYPE_MCE:
1103 rcd->sec_hdr.section_type = CPER_SECTION_TYPE_MCE;
1108 rcd->sec_hdr.section_severity = CPER_SEV_FATAL;
1110 ret = erst_write(&rcd->hdr);
1111 *id = rcd->hdr.record_id;
1116 static int erst_clearer(enum pstore_type_id type, u64 id, int count,
1117 struct timespec time, struct pstore_info *psi)
1119 return erst_clear(id);
1122 static int __init erst_init(void)
1126 struct apei_exec_context ctx;
1127 struct apei_resources erst_resources;
1136 "Error Record Serialization Table (ERST) support is disabled.\n");
1140 status = acpi_get_table(ACPI_SIG_ERST, 0,
1141 (struct acpi_table_header **)&erst_tab);
1142 if (status == AE_NOT_FOUND)
1144 else if (ACPI_FAILURE(status)) {
1145 const char *msg = acpi_format_exception(status);
1146 pr_err("Failed to get table, %s\n", msg);
1151 rc = erst_check_table(erst_tab);
1153 pr_err(FW_BUG "ERST table is invalid.\n");
1157 apei_resources_init(&erst_resources);
1158 erst_exec_ctx_init(&ctx);
1159 rc = apei_exec_collect_resources(&ctx, &erst_resources);
1162 rc = apei_resources_request(&erst_resources, "APEI ERST");
1165 rc = apei_exec_pre_map_gars(&ctx);
1168 rc = erst_get_erange(&erst_erange);
1172 "The corresponding hardware device or firmware implementation "
1173 "is not available.\n");
1175 pr_err("Failed to get Error Log Address Range.\n");
1179 r = request_mem_region(erst_erange.base, erst_erange.size, "APEI ERST");
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);
1188 erst_erange.vaddr = ioremap_cache(erst_erange.base,
1190 if (!erst_erange.vaddr)
1191 goto err_release_erange;
1194 "Error Record Serialization Table (ERST) support is initialized.\n");
1196 buf = kmalloc(erst_erange.size, GFP_KERNEL);
1197 spin_lock_init(&erst_info.buf_lock);
1199 erst_info.buf = buf + sizeof(struct cper_pstore_record);
1200 erst_info.bufsize = erst_erange.size -
1201 sizeof(struct cper_pstore_record);
1202 rc = pstore_register(&erst_info);
1206 "Could not register with persistent store.\n");
1207 erst_info.buf = NULL;
1208 erst_info.bufsize = 0;
1213 "Failed to allocate %lld bytes for persistent store error log.\n",
1219 release_mem_region(erst_erange.base, erst_erange.size);
1221 apei_exec_post_unmap_gars(&ctx);
1223 apei_resources_release(&erst_resources);
1225 apei_resources_fini(&erst_resources);
1231 device_initcall(erst_init);