[mirror_ubuntu-zesty-kernel.git] / arch / powerpc / kvm / book3s_hv_ras.c

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2, as
 * published by the Free Software Foundation.
 *
 * Copyright 2012 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com>
 */

#include <linux/types.h>
#include <linux/string.h>
#include <linux/kvm.h>
#include <linux/kvm_host.h>
#include <linux/kernel.h>
#include <asm/opal.h>
#include <asm/mce.h>
#include <asm/machdep.h>
#include <asm/cputhreads.h>
#include <asm/hmi.h>
#include <asm/kvm_ppc.h>

/* SRR1 bits for machine check on POWER7 */
#define SRR1_MC_LDSTERR		(1ul << (63-42))
#define SRR1_MC_IFETCH_SH	(63-45)
#define SRR1_MC_IFETCH_MASK	0x7
#define SRR1_MC_IFETCH_SLBPAR		2	/* SLB parity error */
#define SRR1_MC_IFETCH_SLBMULTI		3	/* SLB multi-hit */
#define SRR1_MC_IFETCH_SLBPARMULTI	4	/* SLB parity + multi-hit */
#define SRR1_MC_IFETCH_TLBMULTI		5	/* I-TLB multi-hit */

/* DSISR bits for machine check on POWER7 */
#define DSISR_MC_DERAT_MULTI	0x800		/* D-ERAT multi-hit */
#define DSISR_MC_TLB_MULTI	0x400		/* D-TLB multi-hit */
#define DSISR_MC_SLB_PARITY	0x100		/* SLB parity error */
#define DSISR_MC_SLB_MULTI	0x080		/* SLB multi-hit */
#define DSISR_MC_SLB_PARMULTI	0x040		/* SLB parity + multi-hit */

/* POWER7 SLB flush and reload */
static void reload_slb(struct kvm_vcpu *vcpu)
{
	struct slb_shadow *slb;
	unsigned long i, n;

	/* First clear out SLB */
	asm volatile("slbmte %0,%0; slbia" : : "r" (0));

	/* Do they have an SLB shadow buffer registered? */
	slb = vcpu->arch.slb_shadow.pinned_addr;
	if (!slb)
		return;

	/* Sanity check */
	n = min_t(u32, be32_to_cpu(slb->persistent), SLB_MIN_SIZE);
	if ((void *) &slb->save_area[n] > vcpu->arch.slb_shadow.pinned_end)
		return;

	/* Load up the SLB from that */
	for (i = 0; i < n; ++i) {
		unsigned long rb = be64_to_cpu(slb->save_area[i].esid);
		unsigned long rs = be64_to_cpu(slb->save_area[i].vsid);

		rb = (rb & ~0xFFFul) | i;	/* insert entry number */
		asm volatile("slbmte %0,%1" : : "r" (rs), "r" (rb));
	}
}

/*
 * On POWER7, see if we can handle a machine check that occurred inside
 * the guest in real mode, without switching to the host partition.
 *
 * Returns: 0 => exit guest, 1 => deliver machine check to guest
 */
static long kvmppc_realmode_mc_power7(struct kvm_vcpu *vcpu)
{
	unsigned long srr1 = vcpu->arch.shregs.msr;
	struct machine_check_event mce_evt;
	long handled = 1;

	if (srr1 & SRR1_MC_LDSTERR) {
		/* error on load/store */
		unsigned long dsisr = vcpu->arch.shregs.dsisr;

		if (dsisr & (DSISR_MC_SLB_PARMULTI | DSISR_MC_SLB_MULTI |
			     DSISR_MC_SLB_PARITY | DSISR_MC_DERAT_MULTI)) {
			/* flush and reload SLB; flushes D-ERAT too */
			reload_slb(vcpu);
			dsisr &= ~(DSISR_MC_SLB_PARMULTI | DSISR_MC_SLB_MULTI |
				   DSISR_MC_SLB_PARITY | DSISR_MC_DERAT_MULTI);
		}
		if (dsisr & DSISR_MC_TLB_MULTI) {
			if (cur_cpu_spec && cur_cpu_spec->flush_tlb)
				cur_cpu_spec->flush_tlb(TLB_INVAL_SCOPE_LPID);
			dsisr &= ~DSISR_MC_TLB_MULTI;
		}
		/* Any other errors we don't understand? */
		if (dsisr & 0xffffffffUL)
			handled = 0;
	}

	switch ((srr1 >> SRR1_MC_IFETCH_SH) & SRR1_MC_IFETCH_MASK) {
	case 0:
		break;
	case SRR1_MC_IFETCH_SLBPAR:
	case SRR1_MC_IFETCH_SLBMULTI:
	case SRR1_MC_IFETCH_SLBPARMULTI:
		reload_slb(vcpu);
		break;
	case SRR1_MC_IFETCH_TLBMULTI:
		if (cur_cpu_spec && cur_cpu_spec->flush_tlb)
			cur_cpu_spec->flush_tlb(TLB_INVAL_SCOPE_LPID);
		break;
	default:
		handled = 0;
	}

	/*
	 * See if we have already handled the condition in the linux host.
	 * We assume that if the condition is recovered then linux host
	 * will have generated an error log event that we will pick
	 * up and log later.
	 * Don't release mce event now. We will queue up the event so that
	 * we can log the MCE event info on host console.
	 */
	if (!get_mce_event(&mce_evt, MCE_EVENT_DONTRELEASE))
		goto out;

	if (mce_evt.version == MCE_V1 &&
	    (mce_evt.severity == MCE_SEV_NO_ERROR ||
	     mce_evt.disposition == MCE_DISPOSITION_RECOVERED))
		handled = 1;

out:
	/*
	 * We are now going enter guest either through machine check
	 * interrupt (for unhandled errors) or will continue from
	 * current HSRR0 (for handled errors) in guest. Hence
	 * queue up the event so that we can log it from host console later.
	 */
	machine_check_queue_event();

	return handled;
}

long kvmppc_realmode_machine_check(struct kvm_vcpu *vcpu)
{
	return kvmppc_realmode_mc_power7(vcpu);
}

/* Check if dynamic split is in force and return subcore size accordingly. */
static inline int kvmppc_cur_subcore_size(void)
{
	if (local_paca->kvm_hstate.kvm_split_mode)
		return local_paca->kvm_hstate.kvm_split_mode->subcore_size;

	return threads_per_subcore;
}

void kvmppc_subcore_enter_guest(void)
{
	int thread_id, subcore_id;

	thread_id = cpu_thread_in_core(local_paca->paca_index);
	subcore_id = thread_id / kvmppc_cur_subcore_size();

	local_paca->sibling_subcore_state->in_guest[subcore_id] = 1;
}

void kvmppc_subcore_exit_guest(void)
{
	int thread_id, subcore_id;

	thread_id = cpu_thread_in_core(local_paca->paca_index);
	subcore_id = thread_id / kvmppc_cur_subcore_size();

	local_paca->sibling_subcore_state->in_guest[subcore_id] = 0;
}

static bool kvmppc_tb_resync_required(void)
{
	if (test_and_set_bit(CORE_TB_RESYNC_REQ_BIT,
				&local_paca->sibling_subcore_state->flags))
		return false;

	return true;
}

static void kvmppc_tb_resync_done(void)
{
	clear_bit(CORE_TB_RESYNC_REQ_BIT,
			&local_paca->sibling_subcore_state->flags);
}

/*
 * kvmppc_realmode_hmi_handler() is called only by primary thread during
 * guest exit path.
 *
 * There are multiple reasons why HMI could occur, one of them is
 * Timebase (TB) error. If this HMI is due to TB error, then TB would
 * have been in stopped state. The opal hmi handler Will fix it and
 * restore the TB value with host timebase value. For HMI caused due
 * to non-TB errors, opal hmi handler will not touch/restore TB register
 * and hence there won't be any change in TB value.
 *
 * Since we are not sure about the cause of this HMI, we can't be sure
 * about the content of TB register whether it holds guest or host timebase
 * value. Hence the idea is to resync the TB on every HMI, so that we
 * know about the exact state of the TB value. Resync TB call will
 * restore TB to host timebase.
 *
 * Things to consider:
 * - On TB error, HMI interrupt is reported on all the threads of the core
 *   that has encountered TB error irrespective of split-core mode.
 * - The very first thread on the core that get chance to fix TB error
 *   would rsync the TB with local chipTOD value.
 * - The resync TB is a core level action i.e. it will sync all the TBs
 *   in that core independent of split-core mode. This means if we trigger
 *   TB sync from a thread from one subcore, it would affect TB values of
 *   sibling subcores of the same core.
 *
 * All threads need to co-ordinate before making opal hmi handler.
 * All threads will use sibling_subcore_state->in_guest[] (shared by all
 * threads in the core) in paca which holds information about whether
 * sibling subcores are in Guest mode or host mode. The in_guest[] array
 * is of size MAX_SUBCORE_PER_CORE=4, indexed using subcore id to set/unset
 * subcore status. Only primary threads from each subcore is responsible
 * to set/unset its designated array element while entering/exiting the
 * guset.
 *
 * After invoking opal hmi handler call, one of the thread (of entire core)
 * will need to resync the TB. Bit 63 from subcore state bitmap flags
 * (sibling_subcore_state->flags) will be used to co-ordinate between
 * primary threads to decide who takes up the responsibility.
 *
 * This is what we do:
 * - Primary thread from each subcore tries to set resync required bit[63]
 *   of paca->sibling_subcore_state->flags.
 * - The first primary thread that is able to set the flag takes the
 *   responsibility of TB resync. (Let us call it as thread leader)
 * - All other threads which are in host will call
 *   wait_for_subcore_guest_exit() and wait for in_guest[0-3] from
 *   paca->sibling_subcore_state to get cleared.
 * - All the primary thread will clear its subcore status from subcore
 *   state in_guest[] array respectively.
 * - Once all primary threads clear in_guest[0-3], all of them will invoke
 *   opal hmi handler.
 * - Now all threads will wait for TB resync to complete by invoking
 *   wait_for_tb_resync() except the thread leader.
 * - Thread leader will do a TB resync by invoking opal_resync_timebase()
 *   call and the it will clear the resync required bit.
 * - All other threads will now come out of resync wait loop and proceed
 *   with individual execution.
 * - On return of this function, primary thread will signal all
 *   secondary threads to proceed.
 * - All secondary threads will eventually call opal hmi handler on
 *   their exit path.
 */

long kvmppc_realmode_hmi_handler(void)
{
	int ptid = local_paca->kvm_hstate.ptid;
	bool resync_req;

	/* This is only called on primary thread. */
	BUG_ON(ptid != 0);
	__this_cpu_inc(irq_stat.hmi_exceptions);

	/*
	 * By now primary thread has already completed guest->host
	 * partition switch but haven't signaled secondaries yet.
	 * All the secondary threads on this subcore is waiting
	 * for primary thread to signal them to go ahead.
	 *
	 * For threads from subcore which isn't in guest, they all will
	 * wait until all other subcores on this core exit the guest.
	 *
	 * Now set the resync required bit. If you are the first to
	 * set this bit then kvmppc_tb_resync_required() function will
	 * return true. For rest all other subcores
	 * kvmppc_tb_resync_required() will return false.
	 *
	 * If resync_req == true, then this thread is responsible to
	 * initiate TB resync after hmi handler has completed.
	 * All other threads on this core will wait until this thread
	 * clears the resync required bit flag.
	 */
	resync_req = kvmppc_tb_resync_required();

	/* Reset the subcore status to indicate it has exited guest */
	kvmppc_subcore_exit_guest();

	/*
	 * Wait for other subcores on this core to exit the guest.
	 * All the primary threads and threads from subcore that are
	 * not in guest will wait here until all subcores are out
	 * of guest context.
	 */
	wait_for_subcore_guest_exit();

	/*
	 * At this point we are sure that primary threads from each
	 * subcore on this core have completed guest->host partition
	 * switch. Now it is safe to call HMI handler.
	 */
	if (ppc_md.hmi_exception_early)
		ppc_md.hmi_exception_early(NULL);

	/*
	 * Check if this thread is responsible to resync TB.
	 * All other threads will wait until this thread completes the
	 * TB resync.
	 */
	if (resync_req) {
		opal_resync_timebase();
		/* Reset TB resync req bit */
		kvmppc_tb_resync_done();
	} else {
		wait_for_tb_resync();
	}
	return 0;
}
Commit	Line	Data
b4072df4 PM	1	/*
	2	* This program is free software; you can redistribute it and/or modify
	3	* it under the terms of the GNU General Public License, version 2, as
	4	* published by the Free Software Foundation.
	5	*
	6	* Copyright 2012 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com>
	7	*/
	8
	9	#include <linux/types.h>
	10	#include <linux/string.h>
	11	#include <linux/kvm.h>
	12	#include <linux/kvm_host.h>
	13	#include <linux/kernel.h>
	14	#include <asm/opal.h>
36df96f8	15	#include <asm/mce.h>
fd7bacbc MS	16	#include <asm/machdep.h>
	17	#include <asm/cputhreads.h>
	18	#include <asm/hmi.h>
e34af784	19	#include <asm/kvm_ppc.h>
b4072df4 PM	20
	21	/* SRR1 bits for machine check on POWER7 */
	22	#define SRR1_MC_LDSTERR (1ul << (63-42))
	23	#define SRR1_MC_IFETCH_SH (63-45)
	24	#define SRR1_MC_IFETCH_MASK 0x7
	25	#define SRR1_MC_IFETCH_SLBPAR 2 /* SLB parity error */
	26	#define SRR1_MC_IFETCH_SLBMULTI 3 /* SLB multi-hit */
	27	#define SRR1_MC_IFETCH_SLBPARMULTI 4 /* SLB parity + multi-hit */
	28	#define SRR1_MC_IFETCH_TLBMULTI 5 /* I-TLB multi-hit */
	29
	30	/* DSISR bits for machine check on POWER7 */
	31	#define DSISR_MC_DERAT_MULTI 0x800 /* D-ERAT multi-hit */
	32	#define DSISR_MC_TLB_MULTI 0x400 /* D-TLB multi-hit */
	33	#define DSISR_MC_SLB_PARITY 0x100 /* SLB parity error */
	34	#define DSISR_MC_SLB_MULTI 0x080 /* SLB multi-hit */
	35	#define DSISR_MC_SLB_PARMULTI 0x040 /* SLB parity + multi-hit */
	36
	37	/* POWER7 SLB flush and reload */
	38	static void reload_slb(struct kvm_vcpu *vcpu)
	39	{
	40	struct slb_shadow *slb;
	41	unsigned long i, n;
	42
	43	/* First clear out SLB */
	44	asm volatile("slbmte %0,%0; slbia" : : "r" (0));
	45
	46	/* Do they have an SLB shadow buffer registered? */
	47	slb = vcpu->arch.slb_shadow.pinned_addr;
	48	if (!slb)
	49	return;
	50
	51	/* Sanity check */
02407552	52	n = min_t(u32, be32_to_cpu(slb->persistent), SLB_MIN_SIZE);
b4072df4 PM	53	if ((void *) &slb->save_area[n] > vcpu->arch.slb_shadow.pinned_end)
	54	return;
	55
	56	/* Load up the SLB from that */
	57	for (i = 0; i < n; ++i) {
02407552 AG	58	unsigned long rb = be64_to_cpu(slb->save_area[i].esid);
02407552 AG	59	unsigned long rs = be64_to_cpu(slb->save_area[i].vsid);
b4072df4 PM	60
	61	rb = (rb & ~0xFFFul) \| i; /* insert entry number */
	62	asm volatile("slbmte %0,%1" : : "r" (rs), "r" (rb));
	63	}
	64	}
	65
b4072df4 PM	66	/*
	67	* On POWER7, see if we can handle a machine check that occurred inside
	68	* the guest in real mode, without switching to the host partition.
	69	*
	70	* Returns: 0 => exit guest, 1 => deliver machine check to guest
	71	*/
	72	static long kvmppc_realmode_mc_power7(struct kvm_vcpu *vcpu)
	73	{
	74	unsigned long srr1 = vcpu->arch.shregs.msr;
36df96f8	75	struct machine_check_event mce_evt;
b4072df4 PM	76	long handled = 1;
	77
	78	if (srr1 & SRR1_MC_LDSTERR) {
	79	/* error on load/store */
	80	unsigned long dsisr = vcpu->arch.shregs.dsisr;
	81
	82	if (dsisr & (DSISR_MC_SLB_PARMULTI \| DSISR_MC_SLB_MULTI \|
	83	DSISR_MC_SLB_PARITY \| DSISR_MC_DERAT_MULTI)) {
	84	/* flush and reload SLB; flushes D-ERAT too */
	85	reload_slb(vcpu);
	86	dsisr &= ~(DSISR_MC_SLB_PARMULTI \| DSISR_MC_SLB_MULTI \|
	87	DSISR_MC_SLB_PARITY \| DSISR_MC_DERAT_MULTI);
	88	}
	89	if (dsisr & DSISR_MC_TLB_MULTI) {
04407050	90	if (cur_cpu_spec && cur_cpu_spec->flush_tlb)
45706bb5	91	cur_cpu_spec->flush_tlb(TLB_INVAL_SCOPE_LPID);
b4072df4 PM	92	dsisr &= ~DSISR_MC_TLB_MULTI;
	93	}
	94	/* Any other errors we don't understand? */
	95	if (dsisr & 0xffffffffUL)
	96	handled = 0;
	97	}
	98
	99	switch ((srr1 >> SRR1_MC_IFETCH_SH) & SRR1_MC_IFETCH_MASK) {
	100	case 0:
	101	break;
	102	case SRR1_MC_IFETCH_SLBPAR:
	103	case SRR1_MC_IFETCH_SLBMULTI:
	104	case SRR1_MC_IFETCH_SLBPARMULTI:
	105	reload_slb(vcpu);
	106	break;
	107	case SRR1_MC_IFETCH_TLBMULTI:
04407050	108	if (cur_cpu_spec && cur_cpu_spec->flush_tlb)
45706bb5	109	cur_cpu_spec->flush_tlb(TLB_INVAL_SCOPE_LPID);
b4072df4 PM	110	break;
	111	default:
	112	handled = 0;
	113	}
	114
	115	/*
36df96f8 MS	116	* See if we have already handled the condition in the linux host.
36df96f8 MS	117	* We assume that if the condition is recovered then linux host
b4072df4 PM	118	* will have generated an error log event that we will pick
b4072df4 PM	119	* up and log later.
74845bc2 MS	120	* Don't release mce event now. We will queue up the event so that
74845bc2 MS	121	* we can log the MCE event info on host console.
b4072df4	122	*/
36df96f8 MS	123	if (!get_mce_event(&mce_evt, MCE_EVENT_DONTRELEASE))
	124	goto out;
	125
	126	if (mce_evt.version == MCE_V1 &&
	127	(mce_evt.severity == MCE_SEV_NO_ERROR \|\|
	128	mce_evt.disposition == MCE_DISPOSITION_RECOVERED))
b4072df4 PM	129	handled = 1;
b4072df4 PM	130
36df96f8 MS	131	out:
36df96f8 MS	132	/*
74845bc2 MS	133	* We are now going enter guest either through machine check
	134	* interrupt (for unhandled errors) or will continue from
	135	* current HSRR0 (for handled errors) in guest. Hence
	136	* queue up the event so that we can log it from host console later.
36df96f8	137	*/
74845bc2	138	machine_check_queue_event();
b4072df4 PM	139
	140	return handled;
	141	}
	142
	143	long kvmppc_realmode_machine_check(struct kvm_vcpu *vcpu)
	144	{
c17b98cf	145	return kvmppc_realmode_mc_power7(vcpu);
b4072df4	146	}
fd7bacbc MS	147
	148	/* Check if dynamic split is in force and return subcore size accordingly. */
	149	static inline int kvmppc_cur_subcore_size(void)
	150	{
	151	if (local_paca->kvm_hstate.kvm_split_mode)
	152	return local_paca->kvm_hstate.kvm_split_mode->subcore_size;
	153
	154	return threads_per_subcore;
	155	}
	156
	157	void kvmppc_subcore_enter_guest(void)
	158	{
	159	int thread_id, subcore_id;
	160
	161	thread_id = cpu_thread_in_core(local_paca->paca_index);
	162	subcore_id = thread_id / kvmppc_cur_subcore_size();
	163
	164	local_paca->sibling_subcore_state->in_guest[subcore_id] = 1;
	165	}
	166
	167	void kvmppc_subcore_exit_guest(void)
	168	{
	169	int thread_id, subcore_id;
	170
	171	thread_id = cpu_thread_in_core(local_paca->paca_index);
	172	subcore_id = thread_id / kvmppc_cur_subcore_size();
	173
	174	local_paca->sibling_subcore_state->in_guest[subcore_id] = 0;
	175	}
	176
	177	static bool kvmppc_tb_resync_required(void)
	178	{
	179	if (test_and_set_bit(CORE_TB_RESYNC_REQ_BIT,
	180	&local_paca->sibling_subcore_state->flags))
	181	return false;
	182
	183	return true;
	184	}
	185
	186	static void kvmppc_tb_resync_done(void)
	187	{
	188	clear_bit(CORE_TB_RESYNC_REQ_BIT,
	189	&local_paca->sibling_subcore_state->flags);
	190	}
	191
	192	/*
	193	* kvmppc_realmode_hmi_handler() is called only by primary thread during
	194	* guest exit path.
	195	*
	196	* There are multiple reasons why HMI could occur, one of them is
	197	* Timebase (TB) error. If this HMI is due to TB error, then TB would
	198	* have been in stopped state. The opal hmi handler Will fix it and
	199	* restore the TB value with host timebase value. For HMI caused due
	200	* to non-TB errors, opal hmi handler will not touch/restore TB register
	201	* and hence there won't be any change in TB value.
	202	*
	203	* Since we are not sure about the cause of this HMI, we can't be sure
	204	* about the content of TB register whether it holds guest or host timebase
	205	* value. Hence the idea is to resync the TB on every HMI, so that we
	206	* know about the exact state of the TB value. Resync TB call will
	207	* restore TB to host timebase.
	208	*
	209	* Things to consider:
	210	* - On TB error, HMI interrupt is reported on all the threads of the core
211	* that has encountered TB error irrespective of split-core mode.
212	* - The very first thread on the core that get chance to fix TB error
213	* would rsync the TB with local chipTOD value.
214	* - The resync TB is a core level action i.e. it will sync all the TBs
215	* in that core independent of split-core mode. This means if we trigger
216	* TB sync from a thread from one subcore, it would affect TB values of
217	* sibling subcores of the same core.
218	*
219	* All threads need to co-ordinate before making opal hmi handler.
220	* All threads will use sibling_subcore_state->in_guest[] (shared by all
221	* threads in the core) in paca which holds information about whether
222	* sibling subcores are in Guest mode or host mode. The in_guest[] array
223	* is of size MAX_SUBCORE_PER_CORE=4, indexed using subcore id to set/unset
224	* subcore status. Only primary threads from each subcore is responsible
225	* to set/unset its designated array element while entering/exiting the
226	* guset.
227	*
228	* After invoking opal hmi handler call, one of the thread (of entire core)
229	* will need to resync the TB. Bit 63 from subcore state bitmap flags
230	* (sibling_subcore_state->flags) will be used to co-ordinate between
231	* primary threads to decide who takes up the responsibility.
232	*
233	* This is what we do:
234	* - Primary thread from each subcore tries to set resync required bit[63]
235	* of paca->sibling_subcore_state->flags.
236	* - The first primary thread that is able to set the flag takes the
237	* responsibility of TB resync. (Let us call it as thread leader)
238	* - All other threads which are in host will call
239	* wait_for_subcore_guest_exit() and wait for in_guest[0-3] from
240	* paca->sibling_subcore_state to get cleared.
241	* - All the primary thread will clear its subcore status from subcore
242	* state in_guest[] array respectively.
243	* - Once all primary threads clear in_guest[0-3], all of them will invoke
244	* opal hmi handler.
245	* - Now all threads will wait for TB resync to complete by invoking
246	* wait_for_tb_resync() except the thread leader.
247	* - Thread leader will do a TB resync by invoking opal_resync_timebase()
248	* call and the it will clear the resync required bit.
249	* - All other threads will now come out of resync wait loop and proceed
250	* with individual execution.
251	* - On return of this function, primary thread will signal all
252	* secondary threads to proceed.
253	* - All secondary threads will eventually call opal hmi handler on
254	* their exit path.
255	*/
256
257	long kvmppc_realmode_hmi_handler(void)
258	{
259	int ptid = local_paca->kvm_hstate.ptid;
260	bool resync_req;
261
262	/* This is only called on primary thread. */
263	BUG_ON(ptid != 0);
264	__this_cpu_inc(irq_stat.hmi_exceptions);
265
266	/*
267	* By now primary thread has already completed guest->host
268	* partition switch but haven't signaled secondaries yet.
269	* All the secondary threads on this subcore is waiting
270	* for primary thread to signal them to go ahead.
271	*
272	* For threads from subcore which isn't in guest, they all will
273	* wait until all other subcores on this core exit the guest.
274	*
275	* Now set the resync required bit. If you are the first to
276	* set this bit then kvmppc_tb_resync_required() function will
277	* return true. For rest all other subcores
278	* kvmppc_tb_resync_required() will return false.
279	*
280	* If resync_req == true, then this thread is responsible to
281	* initiate TB resync after hmi handler has completed.
282	* All other threads on this core will wait until this thread
283	* clears the resync required bit flag.
284	*/
285	resync_req = kvmppc_tb_resync_required();
286
287	/* Reset the subcore status to indicate it has exited guest */
288	kvmppc_subcore_exit_guest();
289
290	/*
291	* Wait for other subcores on this core to exit the guest.
292	* All the primary threads and threads from subcore that are
293	* not in guest will wait here until all subcores are out
294	* of guest context.
295	*/
296	wait_for_subcore_guest_exit();
297
298	/*
299	* At this point we are sure that primary threads from each
300	* subcore on this core have completed guest->host partition
301	* switch. Now it is safe to call HMI handler.
302	*/
303	if (ppc_md.hmi_exception_early)
304	ppc_md.hmi_exception_early(NULL);
305
306	/*
307	* Check if this thread is responsible to resync TB.
308	* All other threads will wait until this thread completes the
309	* TB resync.
310	*/
311	if (resync_req) {
312	opal_resync_timebase();
313	/* Reset TB resync req bit */
314	kvmppc_tb_resync_done();
315	} else {
316	wait_for_tb_resync();
317	}
318	return 0;
319	}