mach_cpu_states.c revision db874c57ae335a07060499f1492b0d0e2593e26c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/archsystm.h>
#include <sys/autoconf.h>
#include <sys/machsystm.h>
#include <vm/hat_sfmmu.h>
#include <sys/cpu_module.h>
#include <sys/cpu_sgnblk_defs.h>
#include <sys/kdi_impl.h>
#include <sys/hypervisor_api.h>
/*
* hvdump_buf_va is a pointer to the currently-configured hvdump_buf.
* A value of NULL indicates that this area is not configured.
* hvdump_buf_sz is tunable but will be clamped to HVDUMP_SIZE_MAX.
*/
static uint64_t hvdump_buf_pa;
#ifdef TRAPTRACE
#include <sys/traptrace.h>
#include <sys/hypervisor_api.h>
#endif /* TRAPTRACE */
extern u_longlong_t gettick();
static void reboot_machine(char *);
static void update_hvdump_buffer(void);
/*
* For xt_sync synchronization.
*/
extern uint64_t xc_tick_limit;
extern uint64_t xc_tick_jump_limit;
/*
* We keep our own copies, used for cache flushing, because we can be called
* before cpu_fiximpl().
*/
static int kdi_dcache_size;
static int kdi_dcache_linesize;
static int kdi_icache_size;
static int kdi_icache_linesize;
/*
*/
extern void kdi_flush_idcache(int, int, int, int);
/*
* Machine dependent code to reboot.
* "mdep" is interpreted as a character pointer; if non-null, it is a pointer
* to a string to be used as the argument string when rebooting.
*
* "invoke_cb" is a boolean. It is set to true when mdboot() can safely
* invoke CB_CL_MDBOOT callbacks before shutting the system down, i.e. when
* we are in a normal shutdown sequence (interrupts are not blocked, the
* system is not panic'ing or being suspended).
*/
/*ARGSUSED*/
void
{
extern void pm_cfb_check_and_powerup(void);
/*
* XXX - rconsvp is set to NULL to ensure that output messages
* are sent to the underlying "hardware" device using the
* monitor's printf routine since we are in the process of
* either rebooting or halting the machine.
*/
/*
* At a high interrupt level we can't:
* 1) bring up the console
* or
* 2) wait for pending interrupts prior to redistribution
* to the current CPU
*
* so we do them now.
*/
/* make sure there are no more changes to the device tree */
if (invoke_cb)
/*
* Clear any unresolved UEs from memory.
*/
/*
* stop other cpus which also raise our priority. since there is only
* one active cpu after this, and our priority will be too high
* for us to be preempted, we're essentially single threaded
* from here on out.
*/
/*
* try and reset leaf devices. reset_leaves() should only
* be called when there are no other threads that could be
* accessing devices
*/
reset_leaves();
} else if (fcn == AD_POWEROFF) {
} else {
switch (fcn) {
case AD_BOOT:
bootstr = "";
break;
case AD_IBOOT:
bootstr = "-a";
break;
case AD_SBOOT:
bootstr = "-s";
break;
case AD_SIBOOT:
bootstr = "-sa";
break;
default:
"mdboot: invalid function %d", fcn);
bootstr = "";
break;
}
}
}
/* MAYBE REACHED */
}
/* mdpreboot - may be called prior to mdboot while root fs still mounted */
/*ARGSUSED*/
void
{
}
/*
* Halt the machine and then reboot with the device
* and arguments specified in bootstr.
*/
static void
reboot_machine(char *bootstr)
{
stop_other_cpus(); /* send stop signal to other CPUs */
prom_printf("rebooting...\n");
/*
* For platforms that use CPU signatures, we
* need to set the signature block to OS and
* the state to exiting for all the processors.
*/
/*NOTREACHED*/
}
/*
* We use the x-trap mechanism and idle_stop_xcall() to stop the other CPUs.
* Once in panic_idle() they raise spl, record their location, and spin.
*/
static void
panic_idle(void)
{
(void) spl7();
membar_stld();
for (;;);
}
/*
* Force the other CPUs to trap into panic_idle(), and then remove them
* from the cpu_ready_set so they will no longer receive cross-calls.
*/
/*ARGSUSED*/
void
{
int i;
(void) splzs();
for (i = 0; i < NCPU; i++) {
int ntries = 0x10000;
DELAY(50);
ntries--;
}
printf("panic: failed to stop cpu%d\n", i);
}
}
}
/*
* Platform callback following each entry to panicsys(). If we've panicked at
* level 14, we examine t_panic_trap to see if a fatal trap occurred. If so,
* we disable further %tick_cmpr interrupts. If not, an explicit call to panic
* was made and so we re-enqueue an interrupt request structure to allow
* further level 14 interrupts to be processed once we lower PIL. This allows
* us to handle panics from the deadman() CY_HIGH_LEVEL cyclic.
*/
void
panic_enter_hw(int spl)
{
#ifdef TRAPTRACE
if (!panic_tick) {
panic_tick = gettick();
/* there are no possible error codes for this hcall */
&prev_freeze);
}
#endif
} else {
if (!tickcmpr_disabled())
/*
* Clear SOFTINT<14>, SOFTINT<0> (TICK_INT)
* and SOFTINT<16> (STICK_INT) to indicate
* that the current level 14 has been serviced.
*/
}
}
}
/*
* Miscellaneous hardware-specific code to execute after panicstr is set
* by the panic code: we also print and record PTL1 panic information here.
*/
/*ARGSUSED*/
void
{
#ifdef TRAPTRACE
/*
* Turn off TRAPTRACE and save the current %tick value in panic_tick.
*/
if (!panic_tick)
panic_tick = gettick();
/* there are no possible error codes for this hcall */
#endif
/*
* For Platforms that use CPU signatures, we
* need to set the signature block to OS, the state to
* exiting, and the substate to panic for all the processors.
*/
/*
* Disable further ECC errors from the bus nexus.
*/
(void) bus_func_invoke(BF_TYPE_ERRDIS);
/*
* Redirect all interrupts to the current CPU.
*/
/*
* This call exists solely to support dumps to network
* devices after sync from OBP.
*
* If we came here via the sync callback, then on some
* platforms, interrupts may have arrived while we were
* stopped in OBP. OBP will arrange for those interrupts to
* be redelivered if you say "go", but not if you invoke a
* client callback like 'sync'. For some dump devices
* (network swap devices), we need interrupts to be
* delivered in order to dump, so we have to call the bus
* nexus driver to reset the interrupt state machines.
*/
(void) bus_func_invoke(BF_TYPE_RESINTR);
}
/*
* Platforms that use CPU signatures need to set the signature block to OS and
* the state to exiting for all CPUs. PANIC_CONT indicates that we're about to
* reboot the machine if the dump never completes.
*/
/*ARGSUSED*/
void
panic_dump_hw(int spl)
{
}
/*
* for ptl1_panic
*/
void
{
/*CONSTCOND*/
panic("ptl1_init_cpu: not enough space left for ptl1_panic "
"stack, sizeof (struct cpu) = %lu",
(unsigned long)sizeof (struct cpu));
}
}
void
{
static const char *ptl1_reasons[] = {
#ifdef PTL1_PANIC_DEBUG
"trap for debug purpose", /* PTL1_BAD_DEBUG */
#else
"unknown trap", /* PTL1_BAD_DEBUG */
#endif
"register window trap", /* PTL1_BAD_WTRAP */
"kernel MMU miss", /* PTL1_BAD_KMISS */
"kernel protection fault", /* PTL1_BAD_KPROT_FAULT */
"ISM MMU miss", /* PTL1_BAD_ISM */
"kernel MMU trap", /* PTL1_BAD_MMUTRAP */
"kernel trap handler state", /* PTL1_BAD_TRAP */
"floating point trap", /* PTL1_BAD_FPTRAP */
#ifdef DEBUG
"pointer to intr_req", /* PTL1_BAD_INTR_REQ */
#else
"unknown trap", /* PTL1_BAD_INTR_REQ */
#endif
#ifdef TRAPTRACE
"TRACE_PTR state", /* PTL1_BAD_TRACE_PTR */
#else
"unknown trap", /* PTL1_BAD_TRACE_PTR */
#endif
"stack overflow", /* PTL1_BAD_STACK */
"DTrace flags", /* PTL1_BAD_DTRACE_FLAGS */
"attempt to steal locked ctx", /* PTL1_BAD_CTX_STEAL */
"CPU ECC error loop", /* PTL1_BAD_ECC */
"unexpected error from hypervisor call", /* PTL1_BAD_HCALL */
"unexpected global level(%gl)", /* PTL1_BAD_GL */
};
/*
* Use trap_info for a place holder to call panic_savetrap() and
* panic_showtrap() to save and print out ptl1_panic information.
*/
else
}
void
clear_watchdog_on_exit(void)
{
}
void
clear_watchdog_timer(void)
{
}
int
kdi_watchdog_disable(void)
{
return (0); /* sun4v has no watchdog */
}
void
kdi_watchdog_restore(void)
{
/* nothing to do -- no watchdog to re-enable */
}
void
mach_dump_buffer_init(void)
{
if (hvdump_buf_sz > HVDUMP_SIZE_MAX)
if (hvdump_buf_va == NULL)
return;
&minsize);
"dump buffer. Error = 0x%lx, size = 0x%lx,"
"Available buffer size = 0x%lx,"
"Minimum buffer size required = 0x%lx",
}
}
}
static void
update_hvdump_buffer(void)
{
if (hvdump_buf_va == NULL)
return;
&dummy_val);
"buffer. Error = 0x%lx", ret);
}
}
static int
{
int value;
case 0:
break;
case sizeof (int):
break;
default:
break;
}
return (value);
}
/*
* Called by setcpudelay
*/
void
cpu_init_tick_freq(void)
{
}
extern uint64_t xc_tick_limit;
extern uint64_t xc_tick_jump_limit;
#ifdef DEBUG
#define SEND_MONDO_STATS 1
#endif
#ifdef SEND_MONDO_STATS
#endif
void
send_one_mondo(int cpuid)
{
retries = 0;
while (stat != 0) {
/*
* If there is a big jump between the current tick
* count and lasttick, we have probably hit a break
* point. Adjust endtick accordingly to avoid panic.
*/
if (panic_quiesce)
return;
"(target 0x%x) [retries: 0x%x hvstat: 0x%x]",
}
drv_usecwait(1);
retries++;
}
#ifdef SEND_MONDO_STATS
{
if (n < 8192)
x_one_stimes[n >> 7]++;
else if (n < 16*8192)
else
x_one_ltimes[0xf]++;
}
#endif
}
void
{
int ncpuids = 0;
int shipped = 0;
fcpuid = -1;
for (i = 0; i < NCPU; i++) {
if (CPU_IN_SET(set, i)) {
ncpuids++;
if (stat != 0) {
if (fcpuid < 0)
fcpuid = i;
lcpuid = i;
continue;
}
shipped++;
CPUSET_DEL(set, i);
if (CPUSET_ISNULL(set))
break;
}
}
retries = 0;
/*
* If there is a big jump between the current tick
* count and lasttick, we have probably hit a break
* point. Adjust endtick accordingly to avoid panic.
*/
if (panic_quiesce)
return;
"[retries: 0x%x] cpuids: ", retries);
if (CPU_IN_SET(set, i))
}
}
/* adjust fcpuid to the first CPU in set */
break;
/* adjust lcpuid to the last CPU in set */
break;
/* resend undelivered mondo */
if (CPU_IN_SET(set, i)) {
if (stat != 0) {
continue;
}
shipped++;
CPUSET_DEL(set, i);
break;
}
}
break;
;
retries++;
}
#ifdef SEND_MONDO_STATS
{
if (n < 8192)
x_set_stimes[n >> 7]++;
else if (n < 16*8192)
else
x_set_ltimes[0xf]++;
}
x_set_cpus[shipped]++;
#endif
}
void
syncfpu(void)
{
}
void
cpu_flush_ecache(void)
{
}
void
sticksync_slave(void)
{}
void
sticksync_master(void)
{}
void
cpu_init_cache_scrub(void)
{}
int
{
if (watched)
return (ret);
}
int
{
return (0);
}
/*ARGSUSED*/
void
{
}
/*ARGSUSED*/
void
{
}
static int
{
int rc, i;
if (CPU_IN_SET(cpu_ready_set, i))
}
return (rc);
}
/*
* Sends a cross-call to a specified processor. The caller assumes
* responsibility for repetition of cross-calls, as appropriate (MARSA for
* debugging).
*/
static int
{
int stat;
/*
* if (idsr_busy())
* return (KDI_XC_RES_ERR);
*/
if (stat == 0)
return (KDI_XC_RES_OK);
else
return (KDI_XC_RES_NACK);
}
static void
{
}
static void
int icache_linesize)
{
}
/* used directly by kdi_read/write_phys */
void
kdi_flush_caches(void)
{
/* Not required on sun4v architecture. */
}
/*ARGSUSED*/
int
{
return (-1);
}
void
{
}
/*
* Routine to return memory information associated
* with a physical address and syndrome.
*/
/* ARGSUSED */
int
{
return (ENOTSUP);
}
/*
* This routine returns the size of the kernel's FRU name buffer.
*/
{
return (UNUM_NAMLEN);
}
/*
* This routine is a more generic interface to cpu_get_mem_unum(),
* that may be used by other modules (e.g. mm).
*/
/* ARGSUSED */
int
{
return (ENOTSUP);
}
/*
* xt_sync - wait for previous x-traps to finish
*/
void
{
union {
} cpu_sync;
int i;
/*
* Sun4v uses a queue for receiving mondos. Successful
* transmission of a mondo only indicates that the mondo
* has been written into the queue.
*
* We use an array of bytes to let each cpu to signal back
* to the cross trap sender that the cross trap has been
* executed. Set the byte to 1 before sending the cross trap
* and wait until other cpus reset it to 0.
*/
for (i = 0; i < NCPU; i++)
if (CPU_IN_SET(cpuset, i))
for (i = 0; i < (NCPU / 8); i ++) {
/*
* If there is a big jump between the current tick
* count and lasttick, we have probably hit a break
* point. Adjust endtick accordingly to avoid panic.
*/
}
if (panic_quiesce)
goto out;
"at cpu_sync.xword[%d]: 0x%lx\n",
}
}
}
out:
}