Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3760cd20 authored by Chen, Gong's avatar Chen, Gong Committed by Tony Luck
Browse files

CPER: Adjust code flow of some functions 



Some codes can be reorganzied as a common function for other usages.

Signed-off-by: default avatarChen, Gong <gong.chen@linux.intel.com>
Signed-off-by: default avatarTony Luck <tony.luck@intel.com>
parent 0a2409aa

drivers/firmware/efi/cper.c

+100 −55
Original line number Diff line number Diff line
@@ -34,6 +34,9 @@ 
#include <linux/aer.h>



#define INDENT_SP	" "



static char rcd_decode_str[CPER_REC_LEN];



/*

 * CPER record ID need to be unique even after reboot, because record

 * ID is used as index for ERST storage, while CPER records from
@@ -50,18 +53,19 @@ u64 cper_next_record_id(void) 
}

EXPORT_SYMBOL_GPL(cper_next_record_id);



static const char *cper_severity_strs[] = {

static const char * const severity_strs[] = {

	"recoverable",

	"fatal",

	"corrected",

	"info",

};



static const char *cper_severity_str(unsigned int severity)

const char *cper_severity_str(unsigned int severity)

{

	return severity < ARRAY_SIZE(cper_severity_strs) ?

		cper_severity_strs[severity] : "unknown";

	return severity < ARRAY_SIZE(severity_strs) ?

		severity_strs[severity] : "unknown";

}

EXPORT_SYMBOL_GPL(cper_severity_str);



/*

 * cper_print_bits - print strings for set bits
@@ -100,32 +104,32 @@ void cper_print_bits(const char *pfx, unsigned int bits, 
		printk("%s\n", buf);

}



static const char * const cper_proc_type_strs[] = {

static const char * const proc_type_strs[] = {

	"IA32/X64",

	"IA64",

};



static const char * const cper_proc_isa_strs[] = {

static const char * const proc_isa_strs[] = {

	"IA32",

	"IA64",

	"X64",

};



static const char * const cper_proc_error_type_strs[] = {

static const char * const proc_error_type_strs[] = {

	"cache error",

	"TLB error",

	"bus error",

	"micro-architectural error",

};



static const char * const cper_proc_op_strs[] = {

static const char * const proc_op_strs[] = {

	"unknown or generic",

	"data read",

	"data write",

	"instruction execution",

};



static const char * const cper_proc_flag_strs[] = {

static const char * const proc_flag_strs[] = {

	"restartable",

	"precise IP",

	"overflow",
@@ -137,26 +141,26 @@ static void cper_print_proc_generic(const char *pfx, 
{

	if (proc->validation_bits & CPER_PROC_VALID_TYPE)

		printk("%s""processor_type: %d, %s\n", pfx, proc->proc_type,

		       proc->proc_type < ARRAY_SIZE(cper_proc_type_strs) ?

		       cper_proc_type_strs[proc->proc_type] : "unknown");

		       proc->proc_type < ARRAY_SIZE(proc_type_strs) ?

		       proc_type_strs[proc->proc_type] : "unknown");

	if (proc->validation_bits & CPER_PROC_VALID_ISA)

		printk("%s""processor_isa: %d, %s\n", pfx, proc->proc_isa,

		       proc->proc_isa < ARRAY_SIZE(cper_proc_isa_strs) ?

		       cper_proc_isa_strs[proc->proc_isa] : "unknown");

		       proc->proc_isa < ARRAY_SIZE(proc_isa_strs) ?

		       proc_isa_strs[proc->proc_isa] : "unknown");

	if (proc->validation_bits & CPER_PROC_VALID_ERROR_TYPE) {

		printk("%s""error_type: 0x%02x\n", pfx, proc->proc_error_type);

		cper_print_bits(pfx, proc->proc_error_type,

				cper_proc_error_type_strs,

				ARRAY_SIZE(cper_proc_error_type_strs));

				proc_error_type_strs,

				ARRAY_SIZE(proc_error_type_strs));

	}

	if (proc->validation_bits & CPER_PROC_VALID_OPERATION)

		printk("%s""operation: %d, %s\n", pfx, proc->operation,

		       proc->operation < ARRAY_SIZE(cper_proc_op_strs) ?

		       cper_proc_op_strs[proc->operation] : "unknown");

		       proc->operation < ARRAY_SIZE(proc_op_strs) ?

		       proc_op_strs[proc->operation] : "unknown");

	if (proc->validation_bits & CPER_PROC_VALID_FLAGS) {

		printk("%s""flags: 0x%02x\n", pfx, proc->flags);

		cper_print_bits(pfx, proc->flags, cper_proc_flag_strs,

				ARRAY_SIZE(cper_proc_flag_strs));

		cper_print_bits(pfx, proc->flags, proc_flag_strs,

				ARRAY_SIZE(proc_flag_strs));

	}

	if (proc->validation_bits & CPER_PROC_VALID_LEVEL)

		printk("%s""level: %d\n", pfx, proc->level);
@@ -177,7 +181,7 @@ static void cper_print_proc_generic(const char *pfx, 
		printk("%s""IP: 0x%016llx\n", pfx, proc->ip);

}



static const char *cper_mem_err_type_strs[] = {

static const char * const mem_err_type_strs[] = {

	"unknown",

	"no error",

	"single-bit ECC",
@@ -196,58 +200,99 @@ static const char *cper_mem_err_type_strs[] = { 
	"physical memory map-out event",

};



static void cper_print_mem(const char *pfx, const struct cper_sec_mem_err *mem)

const char *cper_mem_err_type_str(unsigned int etype)

{

	if (mem->validation_bits & CPER_MEM_VALID_ERROR_STATUS)

		printk("%s""error_status: 0x%016llx\n", pfx, mem->error_status);

	if (mem->validation_bits & CPER_MEM_VALID_PA)

		printk("%s""physical_address: 0x%016llx\n",

		       pfx, mem->physical_addr);

	if (mem->validation_bits & CPER_MEM_VALID_PA_MASK)

		printk("%s""physical_address_mask: 0x%016llx\n",

		       pfx, mem->physical_addr_mask);

	return etype < ARRAY_SIZE(mem_err_type_strs) ?

		mem_err_type_strs[etype] : "unknown";

}

EXPORT_SYMBOL_GPL(cper_mem_err_type_str);



static int cper_mem_err_location(const struct cper_sec_mem_err *mem, char *msg)

{

	u32 len, n;



	if (!msg)

		return 0;



	n = 0;

	len = CPER_REC_LEN - 1;

	if (mem->validation_bits & CPER_MEM_VALID_NODE)

		pr_debug("node: %d\n", mem->node);

		n += scnprintf(msg + n, len - n, "node: %d ", mem->node);

	if (mem->validation_bits & CPER_MEM_VALID_CARD)

		pr_debug("card: %d\n", mem->card);

		n += scnprintf(msg + n, len - n, "card: %d ", mem->card);

	if (mem->validation_bits & CPER_MEM_VALID_MODULE)

		pr_debug("module: %d\n", mem->module);

		n += scnprintf(msg + n, len - n, "module: %d ", mem->module);

	if (mem->validation_bits & CPER_MEM_VALID_RANK_NUMBER)

		pr_debug("rank: %d\n", mem->rank);

		n += scnprintf(msg + n, len - n, "rank: %d ", mem->rank);

	if (mem->validation_bits & CPER_MEM_VALID_BANK)

		pr_debug("bank: %d\n", mem->bank);

		n += scnprintf(msg + n, len - n, "bank: %d ", mem->bank);

	if (mem->validation_bits & CPER_MEM_VALID_DEVICE)

		pr_debug("device: %d\n", mem->device);

		n += scnprintf(msg + n, len - n, "device: %d ", mem->device);

	if (mem->validation_bits & CPER_MEM_VALID_ROW)

		pr_debug("row: %d\n", mem->row);

		n += scnprintf(msg + n, len - n, "row: %d ", mem->row);

	if (mem->validation_bits & CPER_MEM_VALID_COLUMN)

		pr_debug("column: %d\n", mem->column);

		n += scnprintf(msg + n, len - n, "column: %d ", mem->column);

	if (mem->validation_bits & CPER_MEM_VALID_BIT_POSITION)

		pr_debug("bit_position: %d\n", mem->bit_pos);

		n += scnprintf(msg + n, len - n, "bit_position: %d ",

			       mem->bit_pos);

	if (mem->validation_bits & CPER_MEM_VALID_REQUESTOR_ID)

		pr_debug("requestor_id: 0x%016llx\n", mem->requestor_id);

		n += scnprintf(msg + n, len - n, "requestor_id: 0x%016llx ",

			       mem->requestor_id);

	if (mem->validation_bits & CPER_MEM_VALID_RESPONDER_ID)

		pr_debug("responder_id: 0x%016llx\n", mem->responder_id);

		n += scnprintf(msg + n, len - n, "responder_id: 0x%016llx ",

			       mem->responder_id);

	if (mem->validation_bits & CPER_MEM_VALID_TARGET_ID)

		pr_debug("target_id: 0x%016llx\n", mem->target_id);

	if (mem->validation_bits & CPER_MEM_VALID_ERROR_TYPE) {

		u8 etype = mem->error_type;

		printk("%s""error_type: %d, %s\n", pfx, etype,

		       etype < ARRAY_SIZE(cper_mem_err_type_strs) ?

		       cper_mem_err_type_strs[etype] : "unknown");

		scnprintf(msg + n, len - n, "target_id: 0x%016llx ",

			  mem->target_id);



	msg[n] = '\0';

	return n;

}

	if (mem->validation_bits & CPER_MEM_VALID_MODULE_HANDLE) {



static int cper_dimm_err_location(const struct cper_sec_mem_err *mem, char *msg)

{

	u32 len, n;

	const char *bank = NULL, *device = NULL;



	if (!msg || !(mem->validation_bits & CPER_MEM_VALID_MODULE_HANDLE))

		return 0;



	n = 0;

	len = CPER_REC_LEN - 1;

	dmi_memdev_name(mem->mem_dev_handle, &bank, &device);

		if (bank != NULL && device != NULL)

			printk("%s""DIMM location: %s %s", pfx, bank, device);

	if (bank && device)

		n = snprintf(msg, len, "DIMM location: %s %s ", bank, device);

	else

			printk("%s""DIMM DMI handle: 0x%.4x",

			       pfx, mem->mem_dev_handle);

		n = snprintf(msg, len,

			     "DIMM location: not present. DMI handle: 0x%.4x ",

			     mem->mem_dev_handle);



	msg[n] = '\0';

	return n;

}



static void cper_print_mem(const char *pfx, const struct cper_sec_mem_err *mem)

{

	if (mem->validation_bits & CPER_MEM_VALID_ERROR_STATUS)

		printk("%s""error_status: 0x%016llx\n", pfx, mem->error_status);

	if (mem->validation_bits & CPER_MEM_VALID_PA)

		printk("%s""physical_address: 0x%016llx\n",

		       pfx, mem->physical_addr);

	if (mem->validation_bits & CPER_MEM_VALID_PA_MASK)

		printk("%s""physical_address_mask: 0x%016llx\n",

		       pfx, mem->physical_addr_mask);

	if (cper_mem_err_location(mem, rcd_decode_str))

		printk("%s%s\n", pfx, rcd_decode_str);

	if (mem->validation_bits & CPER_MEM_VALID_ERROR_TYPE) {

		u8 etype = mem->error_type;

		printk("%s""error_type: %d, %s\n", pfx, etype,

		       cper_mem_err_type_str(etype));

	}

	if (cper_dimm_err_location(mem, rcd_decode_str))

		printk("%s%s\n", pfx, rcd_decode_str);

}



static const char *cper_pcie_port_type_strs[] = {

static const char * const pcie_port_type_strs[] = {

	"PCIe end point",

	"legacy PCI end point",

	"unknown",
@@ -266,8 +311,8 @@ static void cper_print_pcie(const char *pfx, const struct cper_sec_pcie *pcie, 
{

	if (pcie->validation_bits & CPER_PCIE_VALID_PORT_TYPE)

		printk("%s""port_type: %d, %s\n", pfx, pcie->port_type,

		       pcie->port_type < ARRAY_SIZE(cper_pcie_port_type_strs) ?

		       cper_pcie_port_type_strs[pcie->port_type] : "unknown");

		       pcie->port_type < ARRAY_SIZE(pcie_port_type_strs) ?

		       pcie_port_type_strs[pcie->port_type] : "unknown");

	if (pcie->validation_bits & CPER_PCIE_VALID_VERSION)

		printk("%s""version: %d.%d\n", pfx,

		       pcie->version.major, pcie->version.minor);

include/linux/cper.h

+9 −0
Original line number Diff line number Diff line
@@ -35,6 +35,13 @@ 
 */

#define CPER_RECORD_REV				0x0100



/*

 * CPER record length contains the CPER fields which are relevant for further

 * handling of a memory error in userspace (we don't carry all the fields

 * defined in the UEFI spec because some of them don't make any sense.)

 * Currently, a length of 256 should be more than enough.

 */

#define CPER_REC_LEN					256

/*

 * Severity difinition for error_severity in struct cper_record_header

 * and section_severity in struct cper_section_descriptor
@@ -395,6 +402,8 @@ struct cper_sec_pcie { 
#pragma pack()



u64 cper_next_record_id(void);

const char *cper_severity_str(unsigned int);

const char *cper_mem_err_type_str(unsigned int);

void cper_print_bits(const char *prefix, unsigned int bits,

		     const char * const strs[], unsigned int strs_size);