|
|
@@ -13,6 +13,9 @@
|
|
|
#include <linux/kernel.h>
|
|
|
#include <asm/opal.h>
|
|
|
#include <asm/mce.h>
|
|
|
+#include <asm/machdep.h>
|
|
|
+#include <asm/cputhreads.h>
|
|
|
+#include <asm/hmi.h>
|
|
|
|
|
|
/* SRR1 bits for machine check on POWER7 */
|
|
|
#define SRR1_MC_LDSTERR (1ul << (63-42))
|
|
|
@@ -140,3 +143,176 @@ 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;
|
|
|
+}
|
Paolo Bonzini