[linux-block.git] / arch / powerpc / kernel / mce.c

/*
 * Machine check exception handling.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * Copyright 2013 IBM Corporation
 * Author: Mahesh Salgaonkar <mahesh@linux.vnet.ibm.com>
 */

#undef DEBUG
#define pr_fmt(fmt) "mce: " fmt

#include <linux/types.h>
#include <linux/ptrace.h>
#include <linux/percpu.h>
#include <linux/export.h>
#include <linux/irq_work.h>
#include <asm/mce.h>

static DEFINE_PER_CPU(int, mce_nest_count);
static DEFINE_PER_CPU(struct machine_check_event[MAX_MC_EVT], mce_event);

/* Queue for delayed MCE events. */
static DEFINE_PER_CPU(int, mce_queue_count);
static DEFINE_PER_CPU(struct machine_check_event[MAX_MC_EVT], mce_event_queue);

static void machine_check_process_queued_event(struct irq_work *work);
static struct irq_work mce_event_process_work = {
        .func = machine_check_process_queued_event,
};

static void mce_set_error_info(struct machine_check_event *mce,
			       struct mce_error_info *mce_err)
{
	mce->error_type = mce_err->error_type;
	switch (mce_err->error_type) {
	case MCE_ERROR_TYPE_UE:
		mce->u.ue_error.ue_error_type = mce_err->u.ue_error_type;
		break;
	case MCE_ERROR_TYPE_SLB:
		mce->u.slb_error.slb_error_type = mce_err->u.slb_error_type;
		break;
	case MCE_ERROR_TYPE_ERAT:
		mce->u.erat_error.erat_error_type = mce_err->u.erat_error_type;
		break;
	case MCE_ERROR_TYPE_TLB:
		mce->u.tlb_error.tlb_error_type = mce_err->u.tlb_error_type;
		break;
	case MCE_ERROR_TYPE_USER:
		mce->u.user_error.user_error_type = mce_err->u.user_error_type;
		break;
	case MCE_ERROR_TYPE_RA:
		mce->u.ra_error.ra_error_type = mce_err->u.ra_error_type;
		break;
	case MCE_ERROR_TYPE_LINK:
		mce->u.link_error.link_error_type = mce_err->u.link_error_type;
		break;
	case MCE_ERROR_TYPE_UNKNOWN:
	default:
		break;
	}
}

/*
 * Decode and save high level MCE information into per cpu buffer which
 * is an array of machine_check_event structure.
 */
void save_mce_event(struct pt_regs *regs, long handled,
		    struct mce_error_info *mce_err,
		    uint64_t nip, uint64_t addr)
{
	int index = __this_cpu_inc_return(mce_nest_count) - 1;
	struct machine_check_event *mce = this_cpu_ptr(&mce_event[index]);

	/*
	 * Return if we don't have enough space to log mce event.
	 * mce_nest_count may go beyond MAX_MC_EVT but that's ok,
	 * the check below will stop buffer overrun.
	 */
	if (index >= MAX_MC_EVT)
		return;

	/* Populate generic machine check info */
	mce->version = MCE_V1;
	mce->srr0 = nip;
	mce->srr1 = regs->msr;
	mce->gpr3 = regs->gpr[3];
	mce->in_use = 1;

	/* Mark it recovered if we have handled it and MSR(RI=1). */
	if (handled && (regs->msr & MSR_RI))
		mce->disposition = MCE_DISPOSITION_RECOVERED;
	else
		mce->disposition = MCE_DISPOSITION_NOT_RECOVERED;

	mce->initiator = mce_err->initiator;
	mce->severity = mce_err->severity;

	/*
	 * Populate the mce error_type and type-specific error_type.
	 */
	mce_set_error_info(mce, mce_err);

	if (!addr)
		return;

	if (mce->error_type == MCE_ERROR_TYPE_TLB) {
		mce->u.tlb_error.effective_address_provided = true;
		mce->u.tlb_error.effective_address = addr;
	} else if (mce->error_type == MCE_ERROR_TYPE_SLB) {
		mce->u.slb_error.effective_address_provided = true;
		mce->u.slb_error.effective_address = addr;
	} else if (mce->error_type == MCE_ERROR_TYPE_ERAT) {
		mce->u.erat_error.effective_address_provided = true;
		mce->u.erat_error.effective_address = addr;
	} else if (mce->error_type == MCE_ERROR_TYPE_USER) {
		mce->u.user_error.effective_address_provided = true;
		mce->u.user_error.effective_address = addr;
	} else if (mce->error_type == MCE_ERROR_TYPE_RA) {
		mce->u.ra_error.effective_address_provided = true;
		mce->u.ra_error.effective_address = addr;
	} else if (mce->error_type == MCE_ERROR_TYPE_LINK) {
		mce->u.link_error.effective_address_provided = true;
		mce->u.link_error.effective_address = addr;
	} else if (mce->error_type == MCE_ERROR_TYPE_UE) {
		mce->u.ue_error.effective_address_provided = true;
		mce->u.ue_error.effective_address = addr;
	}
	return;
}

/*
 * get_mce_event:
 *	mce	Pointer to machine_check_event structure to be filled.
 *	release Flag to indicate whether to free the event slot or not.
 *		0 <= do not release the mce event. Caller will invoke
 *		     release_mce_event() once event has been consumed.
 *		1 <= release the slot.
 *
 *	return	1 = success
 *		0 = failure
 *
 * get_mce_event() will be called by platform specific machine check
 * handle routine and in KVM.
 * When we call get_mce_event(), we are still in interrupt context and
 * preemption will not be scheduled until ret_from_expect() routine
 * is called.
 */
int get_mce_event(struct machine_check_event *mce, bool release)
{
	int index = __this_cpu_read(mce_nest_count) - 1;
	struct machine_check_event *mc_evt;
	int ret = 0;

	/* Sanity check */
	if (index < 0)
		return ret;

	/* Check if we have MCE info to process. */
	if (index < MAX_MC_EVT) {
		mc_evt = this_cpu_ptr(&mce_event[index]);
		/* Copy the event structure and release the original */
		if (mce)
			*mce = *mc_evt;
		if (release)
			mc_evt->in_use = 0;
		ret = 1;
	}
	/* Decrement the count to free the slot. */
	if (release)
		__this_cpu_dec(mce_nest_count);

	return ret;
}

void release_mce_event(void)
{
	get_mce_event(NULL, true);
}

/*
 * Queue up the MCE event which then can be handled later.
 */
void machine_check_queue_event(void)
{
	int index;
	struct machine_check_event evt;

	if (!get_mce_event(&evt, MCE_EVENT_RELEASE))
		return;

	index = __this_cpu_inc_return(mce_queue_count) - 1;
	/* If queue is full, just return for now. */
	if (index >= MAX_MC_EVT) {
		__this_cpu_dec(mce_queue_count);
		return;
	}
	memcpy(this_cpu_ptr(&mce_event_queue[index]), &evt, sizeof(evt));

	/* Queue irq work to process this event later. */
	irq_work_queue(&mce_event_process_work);
}

/*
 * process pending MCE event from the mce event queue. This function will be
 * called during syscall exit.
 */
static void machine_check_process_queued_event(struct irq_work *work)
{
	int index;

	add_taint(TAINT_MACHINE_CHECK, LOCKDEP_NOW_UNRELIABLE);

	/*
	 * For now just print it to console.
	 * TODO: log this error event to FSP or nvram.
	 */
	while (__this_cpu_read(mce_queue_count) > 0) {
		index = __this_cpu_read(mce_queue_count) - 1;
		machine_check_print_event_info(
				this_cpu_ptr(&mce_event_queue[index]), false);
		__this_cpu_dec(mce_queue_count);
	}
}

void machine_check_print_event_info(struct machine_check_event *evt,
				    bool user_mode)
{
	const char *level, *sevstr, *subtype;
	static const char *mc_ue_types[] = {
		"Indeterminate",
		"Instruction fetch",
		"Page table walk ifetch",
		"Load/Store",
		"Page table walk Load/Store",
	};
	static const char *mc_slb_types[] = {
		"Indeterminate",
		"Parity",
		"Multihit",
	};
	static const char *mc_erat_types[] = {
		"Indeterminate",
		"Parity",
		"Multihit",
	};
	static const char *mc_tlb_types[] = {
		"Indeterminate",
		"Parity",
		"Multihit",
	};
	static const char *mc_user_types[] = {
		"Indeterminate",
		"tlbie(l) invalid",
	};
	static const char *mc_ra_types[] = {
		"Indeterminate",
		"Instruction fetch (bad)",
		"Page table walk ifetch (bad)",
		"Page table walk ifetch (foreign)",
		"Load (bad)",
		"Store (bad)",
		"Page table walk Load/Store (bad)",
		"Page table walk Load/Store (foreign)",
		"Load/Store (foreign)",
	};
	static const char *mc_link_types[] = {
		"Indeterminate",
		"Instruction fetch (timeout)",
		"Page table walk ifetch (timeout)",
		"Load (timeout)",
		"Store (timeout)",
		"Page table walk Load/Store (timeout)",
	};

	/* Print things out */
	if (evt->version != MCE_V1) {
		pr_err("Machine Check Exception, Unknown event version %d !\n",
		       evt->version);
		return;
	}
	switch (evt->severity) {
	case MCE_SEV_NO_ERROR:
		level = KERN_INFO;
		sevstr = "Harmless";
		break;
	case MCE_SEV_WARNING:
		level = KERN_WARNING;
		sevstr = "";
		break;
	case MCE_SEV_ERROR_SYNC:
		level = KERN_ERR;
		sevstr = "Severe";
		break;
	case MCE_SEV_FATAL:
	default:
		level = KERN_ERR;
		sevstr = "Fatal";
		break;
	}

	printk("%s%s Machine check interrupt [%s]\n", level, sevstr,
	       evt->disposition == MCE_DISPOSITION_RECOVERED ?
	       "Recovered" : "Not recovered");

	if (user_mode) {
		printk("%s  NIP: [%016llx] PID: %d Comm: %s\n", level,
			evt->srr0, current->pid, current->comm);
	} else {
		printk("%s  NIP [%016llx]: %pS\n", level, evt->srr0,
		       (void *)evt->srr0);
	}

	printk("%s  Initiator: %s\n", level,
	       evt->initiator == MCE_INITIATOR_CPU ? "CPU" : "Unknown");
	switch (evt->error_type) {
	case MCE_ERROR_TYPE_UE:
		subtype = evt->u.ue_error.ue_error_type <
			ARRAY_SIZE(mc_ue_types) ?
			mc_ue_types[evt->u.ue_error.ue_error_type]
			: "Unknown";
		printk("%s  Error type: UE [%s]\n", level, subtype);
		if (evt->u.ue_error.effective_address_provided)
			printk("%s    Effective address: %016llx\n",
			       level, evt->u.ue_error.effective_address);
		if (evt->u.ue_error.physical_address_provided)
			printk("%s      Physical address: %016llx\n",
			       level, evt->u.ue_error.physical_address);
		break;
	case MCE_ERROR_TYPE_SLB:
		subtype = evt->u.slb_error.slb_error_type <
			ARRAY_SIZE(mc_slb_types) ?
			mc_slb_types[evt->u.slb_error.slb_error_type]
			: "Unknown";
		printk("%s  Error type: SLB [%s]\n", level, subtype);
		if (evt->u.slb_error.effective_address_provided)
			printk("%s    Effective address: %016llx\n",
			       level, evt->u.slb_error.effective_address);
		break;
	case MCE_ERROR_TYPE_ERAT:
		subtype = evt->u.erat_error.erat_error_type <
			ARRAY_SIZE(mc_erat_types) ?
			mc_erat_types[evt->u.erat_error.erat_error_type]
			: "Unknown";
		printk("%s  Error type: ERAT [%s]\n", level, subtype);
		if (evt->u.erat_error.effective_address_provided)
			printk("%s    Effective address: %016llx\n",
			       level, evt->u.erat_error.effective_address);
		break;
	case MCE_ERROR_TYPE_TLB:
		subtype = evt->u.tlb_error.tlb_error_type <
			ARRAY_SIZE(mc_tlb_types) ?
			mc_tlb_types[evt->u.tlb_error.tlb_error_type]
			: "Unknown";
		printk("%s  Error type: TLB [%s]\n", level, subtype);
		if (evt->u.tlb_error.effective_address_provided)
			printk("%s    Effective address: %016llx\n",
			       level, evt->u.tlb_error.effective_address);
		break;
	case MCE_ERROR_TYPE_USER:
		subtype = evt->u.user_error.user_error_type <
			ARRAY_SIZE(mc_user_types) ?
			mc_user_types[evt->u.user_error.user_error_type]
			: "Unknown";
		printk("%s  Error type: User [%s]\n", level, subtype);
		if (evt->u.user_error.effective_address_provided)
			printk("%s    Effective address: %016llx\n",
			       level, evt->u.user_error.effective_address);
		break;
	case MCE_ERROR_TYPE_RA:
		subtype = evt->u.ra_error.ra_error_type <
			ARRAY_SIZE(mc_ra_types) ?
			mc_ra_types[evt->u.ra_error.ra_error_type]
			: "Unknown";
		printk("%s  Error type: Real address [%s]\n", level, subtype);
		if (evt->u.ra_error.effective_address_provided)
			printk("%s    Effective address: %016llx\n",
			       level, evt->u.ra_error.effective_address);
		break;
	case MCE_ERROR_TYPE_LINK:
		subtype = evt->u.link_error.link_error_type <
			ARRAY_SIZE(mc_link_types) ?
			mc_link_types[evt->u.link_error.link_error_type]
			: "Unknown";
		printk("%s  Error type: Link [%s]\n", level, subtype);
		if (evt->u.link_error.effective_address_provided)
			printk("%s    Effective address: %016llx\n",
			       level, evt->u.link_error.effective_address);
		break;
	default:
	case MCE_ERROR_TYPE_UNKNOWN:
		printk("%s  Error type: Unknown\n", level);
		break;
	}
}

uint64_t get_mce_fault_addr(struct machine_check_event *evt)
{
	switch (evt->error_type) {
	case MCE_ERROR_TYPE_UE:
		if (evt->u.ue_error.effective_address_provided)
			return evt->u.ue_error.effective_address;
		break;
	case MCE_ERROR_TYPE_SLB:
		if (evt->u.slb_error.effective_address_provided)
			return evt->u.slb_error.effective_address;
		break;
	case MCE_ERROR_TYPE_ERAT:
		if (evt->u.erat_error.effective_address_provided)
			return evt->u.erat_error.effective_address;
		break;
	case MCE_ERROR_TYPE_TLB:
		if (evt->u.tlb_error.effective_address_provided)
			return evt->u.tlb_error.effective_address;
		break;
	case MCE_ERROR_TYPE_USER:
		if (evt->u.user_error.effective_address_provided)
			return evt->u.user_error.effective_address;
		break;
	case MCE_ERROR_TYPE_RA:
		if (evt->u.ra_error.effective_address_provided)
			return evt->u.ra_error.effective_address;
		break;
	case MCE_ERROR_TYPE_LINK:
		if (evt->u.link_error.effective_address_provided)
			return evt->u.link_error.effective_address;
		break;
	default:
	case MCE_ERROR_TYPE_UNKNOWN:
		break;
	}
	return 0;
}
EXPORT_SYMBOL(get_mce_fault_addr);
Commit	Line	Data
36df96f8 MS	1	/*
	2	* Machine check exception handling.
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; either version 2 of the License, or
	7	* (at your option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	17	*
	18	* Copyright 2013 IBM Corporation
	19	* Author: Mahesh Salgaonkar <mahesh@linux.vnet.ibm.com>
	20	*/
	21
	22	#undef DEBUG
	23	#define pr_fmt(fmt) "mce: " fmt
	24
	25	#include <linux/types.h>
	26	#include <linux/ptrace.h>
	27	#include <linux/percpu.h>
	28	#include <linux/export.h>
30c82635	29	#include <linux/irq_work.h>
36df96f8 MS	30	#include <asm/mce.h>
	31
	32	static DEFINE_PER_CPU(int, mce_nest_count);
	33	static DEFINE_PER_CPU(struct machine_check_event[MAX_MC_EVT], mce_event);
	34
b5ff4211 MS	35	/* Queue for delayed MCE events. */
	36	static DEFINE_PER_CPU(int, mce_queue_count);
	37	static DEFINE_PER_CPU(struct machine_check_event[MAX_MC_EVT], mce_event_queue);
	38
30c82635	39	static void machine_check_process_queued_event(struct irq_work *work);
635218c7	40	static struct irq_work mce_event_process_work = {
30c82635 MS	41	.func = machine_check_process_queued_event,
	42	};
	43
36df96f8 MS	44	static void mce_set_error_info(struct machine_check_event *mce,
	45	struct mce_error_info *mce_err)
	46	{
	47	mce->error_type = mce_err->error_type;
	48	switch (mce_err->error_type) {
	49	case MCE_ERROR_TYPE_UE:
	50	mce->u.ue_error.ue_error_type = mce_err->u.ue_error_type;
	51	break;
	52	case MCE_ERROR_TYPE_SLB:
	53	mce->u.slb_error.slb_error_type = mce_err->u.slb_error_type;
	54	break;
	55	case MCE_ERROR_TYPE_ERAT:
	56	mce->u.erat_error.erat_error_type = mce_err->u.erat_error_type;
	57	break;
	58	case MCE_ERROR_TYPE_TLB:
	59	mce->u.tlb_error.tlb_error_type = mce_err->u.tlb_error_type;
	60	break;
7b9f71f9 NP	61	case MCE_ERROR_TYPE_USER:
	62	mce->u.user_error.user_error_type = mce_err->u.user_error_type;
	63	break;
	64	case MCE_ERROR_TYPE_RA:
	65	mce->u.ra_error.ra_error_type = mce_err->u.ra_error_type;
	66	break;
	67	case MCE_ERROR_TYPE_LINK:
	68	mce->u.link_error.link_error_type = mce_err->u.link_error_type;
	69	break;
36df96f8 MS	70	case MCE_ERROR_TYPE_UNKNOWN:
	71	default:
	72	break;
	73	}
	74	}
	75
	76	/*
	77	* Decode and save high level MCE information into per cpu buffer which
	78	* is an array of machine_check_event structure.
	79	*/
	80	void save_mce_event(struct pt_regs *regs, long handled,
	81	struct mce_error_info *mce_err,
55672ecf	82	uint64_t nip, uint64_t addr)
36df96f8	83	{
ffb2d78e	84	int index = __this_cpu_inc_return(mce_nest_count) - 1;
69111bac	85	struct machine_check_event *mce = this_cpu_ptr(&mce_event[index]);
36df96f8 MS	86
	87	/*
	88	* Return if we don't have enough space to log mce event.
	89	* mce_nest_count may go beyond MAX_MC_EVT but that's ok,
	90	* the check below will stop buffer overrun.
	91	*/
	92	if (index >= MAX_MC_EVT)
	93	return;
	94
	95	/* Populate generic machine check info */
	96	mce->version = MCE_V1;
55672ecf	97	mce->srr0 = nip;
36df96f8 MS	98	mce->srr1 = regs->msr;
	99	mce->gpr3 = regs->gpr[3];
	100	mce->in_use = 1;
	101
c74dd88e MS	102	/* Mark it recovered if we have handled it and MSR(RI=1). */
c74dd88e MS	103	if (handled && (regs->msr & MSR_RI))
36df96f8 MS	104	mce->disposition = MCE_DISPOSITION_RECOVERED;
	105	else
	106	mce->disposition = MCE_DISPOSITION_NOT_RECOVERED;
c1bbf387 NP	107
	108	mce->initiator = mce_err->initiator;
	109	mce->severity = mce_err->severity;
36df96f8	110
36df96f8 MS	111	/*
	112	* Populate the mce error_type and type-specific error_type.
	113	*/
	114	mce_set_error_info(mce, mce_err);
	115
	116	if (!addr)
	117	return;
	118
	119	if (mce->error_type == MCE_ERROR_TYPE_TLB) {
	120	mce->u.tlb_error.effective_address_provided = true;
	121	mce->u.tlb_error.effective_address = addr;
	122	} else if (mce->error_type == MCE_ERROR_TYPE_SLB) {
	123	mce->u.slb_error.effective_address_provided = true;
	124	mce->u.slb_error.effective_address = addr;
	125	} else if (mce->error_type == MCE_ERROR_TYPE_ERAT) {
	126	mce->u.erat_error.effective_address_provided = true;
	127	mce->u.erat_error.effective_address = addr;
7b9f71f9 NP	128	} else if (mce->error_type == MCE_ERROR_TYPE_USER) {
	129	mce->u.user_error.effective_address_provided = true;
	130	mce->u.user_error.effective_address = addr;
	131	} else if (mce->error_type == MCE_ERROR_TYPE_RA) {
	132	mce->u.ra_error.effective_address_provided = true;
	133	mce->u.ra_error.effective_address = addr;
	134	} else if (mce->error_type == MCE_ERROR_TYPE_LINK) {
	135	mce->u.link_error.effective_address_provided = true;
	136	mce->u.link_error.effective_address = addr;
36df96f8 MS	137	} else if (mce->error_type == MCE_ERROR_TYPE_UE) {
	138	mce->u.ue_error.effective_address_provided = true;
	139	mce->u.ue_error.effective_address = addr;
	140	}
	141	return;
	142	}
	143
	144	/*
	145	* get_mce_event:
	146	* mce Pointer to machine_check_event structure to be filled.
	147	* release Flag to indicate whether to free the event slot or not.
	148	* 0 <= do not release the mce event. Caller will invoke
	149	* release_mce_event() once event has been consumed.
	150	* 1 <= release the slot.
	151	*
	152	* return 1 = success
	153	* 0 = failure
	154	*
	155	* get_mce_event() will be called by platform specific machine check
	156	* handle routine and in KVM.
	157	* When we call get_mce_event(), we are still in interrupt context and
	158	* preemption will not be scheduled until ret_from_expect() routine
	159	* is called.
	160	*/
	161	int get_mce_event(struct machine_check_event *mce, bool release)
	162	{
69111bac	163	int index = __this_cpu_read(mce_nest_count) - 1;
36df96f8 MS	164	struct machine_check_event *mc_evt;
	165	int ret = 0;
	166
	167	/* Sanity check */
	168	if (index < 0)
	169	return ret;
	170
	171	/* Check if we have MCE info to process. */
	172	if (index < MAX_MC_EVT) {
69111bac	173	mc_evt = this_cpu_ptr(&mce_event[index]);
36df96f8 MS	174	/* Copy the event structure and release the original */
	175	if (mce)
	176	mce = mc_evt;
	177	if (release)
	178	mc_evt->in_use = 0;
	179	ret = 1;
	180	}
	181	/* Decrement the count to free the slot. */
	182	if (release)
69111bac	183	__this_cpu_dec(mce_nest_count);
36df96f8 MS	184
	185	return ret;
	186	}
	187
	188	void release_mce_event(void)
	189	{
	190	get_mce_event(NULL, true);
	191	}
b5ff4211 MS	192
	193	/*
	194	* Queue up the MCE event which then can be handled later.
	195	*/
	196	void machine_check_queue_event(void)
	197	{
	198	int index;
	199	struct machine_check_event evt;
	200
	201	if (!get_mce_event(&evt, MCE_EVENT_RELEASE))
	202	return;
	203
ffb2d78e	204	index = __this_cpu_inc_return(mce_queue_count) - 1;
b5ff4211 MS	205	/* If queue is full, just return for now. */
b5ff4211 MS	206	if (index >= MAX_MC_EVT) {
69111bac	207	__this_cpu_dec(mce_queue_count);
b5ff4211 MS	208	return;
b5ff4211 MS	209	}
69111bac	210	memcpy(this_cpu_ptr(&mce_event_queue[index]), &evt, sizeof(evt));
30c82635 MS	211
	212	/* Queue irq work to process this event later. */
	213	irq_work_queue(&mce_event_process_work);
b5ff4211 MS	214	}
	215
	216	/*
	217	* process pending MCE event from the mce event queue. This function will be
	218	* called during syscall exit.
	219	*/
30c82635	220	static void machine_check_process_queued_event(struct irq_work *work)
b5ff4211 MS	221	{
	222	int index;
	223
d93b0ac0 MS	224	add_taint(TAINT_MACHINE_CHECK, LOCKDEP_NOW_UNRELIABLE);
d93b0ac0 MS	225
b5ff4211 MS	226	/*
	227	* For now just print it to console.
	228	* TODO: log this error event to FSP or nvram.
	229	*/
69111bac CL	230	while (__this_cpu_read(mce_queue_count) > 0) {
69111bac CL	231	index = __this_cpu_read(mce_queue_count) - 1;
b5ff4211	232	machine_check_print_event_info(
63f44d65	233	this_cpu_ptr(&mce_event_queue[index]), false);
69111bac	234	__this_cpu_dec(mce_queue_count);
b5ff4211	235	}
b5ff4211 MS	236	}
b5ff4211 MS	237
63f44d65 ME	238	void machine_check_print_event_info(struct machine_check_event *evt,
63f44d65 ME	239	bool user_mode)
b5ff4211 MS	240	{
	241	const char level, sevstr, *subtype;
	242	static const char *mc_ue_types[] = {
	243	"Indeterminate",
	244	"Instruction fetch",
	245	"Page table walk ifetch",
	246	"Load/Store",
	247	"Page table walk Load/Store",
	248	};
	249	static const char *mc_slb_types[] = {
	250	"Indeterminate",
	251	"Parity",
	252	"Multihit",
	253	};
	254	static const char *mc_erat_types[] = {
	255	"Indeterminate",
	256	"Parity",
	257	"Multihit",
	258	};
	259	static const char *mc_tlb_types[] = {
	260	"Indeterminate",
	261	"Parity",
	262	"Multihit",
	263	};
7b9f71f9 NP	264	static const char *mc_user_types[] = {
	265	"Indeterminate",
	266	"tlbie(l) invalid",
	267	};
	268	static const char *mc_ra_types[] = {
	269	"Indeterminate",
	270	"Instruction fetch (bad)",
	271	"Page table walk ifetch (bad)",
	272	"Page table walk ifetch (foreign)",
	273	"Load (bad)",
	274	"Store (bad)",
	275	"Page table walk Load/Store (bad)",
	276	"Page table walk Load/Store (foreign)",
	277	"Load/Store (foreign)",
	278	};
	279	static const char *mc_link_types[] = {
	280	"Indeterminate",
	281	"Instruction fetch (timeout)",
	282	"Page table walk ifetch (timeout)",
	283	"Load (timeout)",
	284	"Store (timeout)",
	285	"Page table walk Load/Store (timeout)",
	286	};
b5ff4211 MS	287
	288	/* Print things out */
	289	if (evt->version != MCE_V1) {
	290	pr_err("Machine Check Exception, Unknown event version %d !\n",
	291	evt->version);
	292	return;
	293	}
	294	switch (evt->severity) {
	295	case MCE_SEV_NO_ERROR:
	296	level = KERN_INFO;
	297	sevstr = "Harmless";
	298	break;
	299	case MCE_SEV_WARNING:
	300	level = KERN_WARNING;
	301	sevstr = "";
	302	break;
	303	case MCE_SEV_ERROR_SYNC:
	304	level = KERN_ERR;
	305	sevstr = "Severe";
	306	break;
	307	case MCE_SEV_FATAL:
	308	default:
	309	level = KERN_ERR;
	310	sevstr = "Fatal";
	311	break;
	312	}
	313
	314	printk("%s%s Machine check interrupt [%s]\n", level, sevstr,
	315	evt->disposition == MCE_DISPOSITION_RECOVERED ?
fc84427b	316	"Recovered" : "Not recovered");
63f44d65 ME	317
	318	if (user_mode) {
	319	printk("%s NIP: [%016llx] PID: %d Comm: %s\n", level,
	320	evt->srr0, current->pid, current->comm);
	321	} else {
	322	printk("%s NIP [%016llx]: %pS\n", level, evt->srr0,
	323	(void *)evt->srr0);
	324	}
	325
b5ff4211 MS	326	printk("%s Initiator: %s\n", level,
	327	evt->initiator == MCE_INITIATOR_CPU ? "CPU" : "Unknown");
	328	switch (evt->error_type) {
	329	case MCE_ERROR_TYPE_UE:
	330	subtype = evt->u.ue_error.ue_error_type <
	331	ARRAY_SIZE(mc_ue_types) ?
	332	mc_ue_types[evt->u.ue_error.ue_error_type]
	333	: "Unknown";
	334	printk("%s Error type: UE [%s]\n", level, subtype);
	335	if (evt->u.ue_error.effective_address_provided)
	336	printk("%s Effective address: %016llx\n",
	337	level, evt->u.ue_error.effective_address);
	338	if (evt->u.ue_error.physical_address_provided)
c01e0159	339	printk("%s Physical address: %016llx\n",
b5ff4211 MS	340	level, evt->u.ue_error.physical_address);
	341	break;
	342	case MCE_ERROR_TYPE_SLB:
	343	subtype = evt->u.slb_error.slb_error_type <
	344	ARRAY_SIZE(mc_slb_types) ?
	345	mc_slb_types[evt->u.slb_error.slb_error_type]
	346	: "Unknown";
	347	printk("%s Error type: SLB [%s]\n", level, subtype);
	348	if (evt->u.slb_error.effective_address_provided)
	349	printk("%s Effective address: %016llx\n",
	350	level, evt->u.slb_error.effective_address);
	351	break;
	352	case MCE_ERROR_TYPE_ERAT:
	353	subtype = evt->u.erat_error.erat_error_type <
	354	ARRAY_SIZE(mc_erat_types) ?
	355	mc_erat_types[evt->u.erat_error.erat_error_type]
	356	: "Unknown";
	357	printk("%s Error type: ERAT [%s]\n", level, subtype);
	358	if (evt->u.erat_error.effective_address_provided)
	359	printk("%s Effective address: %016llx\n",
	360	level, evt->u.erat_error.effective_address);
	361	break;
	362	case MCE_ERROR_TYPE_TLB:
	363	subtype = evt->u.tlb_error.tlb_error_type <
	364	ARRAY_SIZE(mc_tlb_types) ?
	365	mc_tlb_types[evt->u.tlb_error.tlb_error_type]
	366	: "Unknown";
	367	printk("%s Error type: TLB [%s]\n", level, subtype);
	368	if (evt->u.tlb_error.effective_address_provided)
	369	printk("%s Effective address: %016llx\n",
	370	level, evt->u.tlb_error.effective_address);
	371	break;
7b9f71f9 NP	372	case MCE_ERROR_TYPE_USER:
	373	subtype = evt->u.user_error.user_error_type <
	374	ARRAY_SIZE(mc_user_types) ?
	375	mc_user_types[evt->u.user_error.user_error_type]
	376	: "Unknown";
	377	printk("%s Error type: User [%s]\n", level, subtype);
	378	if (evt->u.user_error.effective_address_provided)
	379	printk("%s Effective address: %016llx\n",
	380	level, evt->u.user_error.effective_address);
	381	break;
	382	case MCE_ERROR_TYPE_RA:
	383	subtype = evt->u.ra_error.ra_error_type <
	384	ARRAY_SIZE(mc_ra_types) ?
	385	mc_ra_types[evt->u.ra_error.ra_error_type]
	386	: "Unknown";
	387	printk("%s Error type: Real address [%s]\n", level, subtype);
	388	if (evt->u.ra_error.effective_address_provided)
	389	printk("%s Effective address: %016llx\n",
	390	level, evt->u.ra_error.effective_address);
	391	break;
	392	case MCE_ERROR_TYPE_LINK:
	393	subtype = evt->u.link_error.link_error_type <
	394	ARRAY_SIZE(mc_link_types) ?
	395	mc_link_types[evt->u.link_error.link_error_type]
	396	: "Unknown";
	397	printk("%s Error type: Link [%s]\n", level, subtype);
	398	if (evt->u.link_error.effective_address_provided)
	399	printk("%s Effective address: %016llx\n",
	400	level, evt->u.link_error.effective_address);
	401	break;
b5ff4211 MS	402	default:
	403	case MCE_ERROR_TYPE_UNKNOWN:
	404	printk("%s Error type: Unknown\n", level);
	405	break;
	406	}
	407	}
b63a0ffe MS	408
	409	uint64_t get_mce_fault_addr(struct machine_check_event *evt)
	410	{
	411	switch (evt->error_type) {
	412	case MCE_ERROR_TYPE_UE:
	413	if (evt->u.ue_error.effective_address_provided)
	414	return evt->u.ue_error.effective_address;
	415	break;
	416	case MCE_ERROR_TYPE_SLB:
	417	if (evt->u.slb_error.effective_address_provided)
	418	return evt->u.slb_error.effective_address;
	419	break;
	420	case MCE_ERROR_TYPE_ERAT:
	421	if (evt->u.erat_error.effective_address_provided)
	422	return evt->u.erat_error.effective_address;
	423	break;
	424	case MCE_ERROR_TYPE_TLB:
	425	if (evt->u.tlb_error.effective_address_provided)
	426	return evt->u.tlb_error.effective_address;
	427	break;
7b9f71f9 NP	428	case MCE_ERROR_TYPE_USER:
	429	if (evt->u.user_error.effective_address_provided)
	430	return evt->u.user_error.effective_address;
	431	break;
	432	case MCE_ERROR_TYPE_RA:
	433	if (evt->u.ra_error.effective_address_provided)
	434	return evt->u.ra_error.effective_address;
	435	break;
	436	case MCE_ERROR_TYPE_LINK:
	437	if (evt->u.link_error.effective_address_provided)
	438	return evt->u.link_error.effective_address;
	439	break;
b63a0ffe MS	440	default:
	441	case MCE_ERROR_TYPE_UNKNOWN:
	442	break;
	443	}
	444	return 0;
	445	}
	446	EXPORT_SYMBOL(get_mce_fault_addr);