xref: /onnv-gate/usr/src/uts/sparc/os/archdep.c (revision 12967:ab9ae749152f)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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
 * or http://www.opensolaris.org/os/licensing.
 * 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 (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/


#include <sys/param.h>
#include <sys/types.h>
#include <sys/vmparam.h>
#include <sys/systm.h>
#include <sys/sysmacros.h>
#include <sys/signal.h>
#include <sys/stack.h>
#include <sys/frame.h>
#include <sys/proc.h>
#include <sys/ucontext.h>
#include <sys/siginfo.h>
#include <sys/cpuvar.h>
#include <sys/asm_linkage.h>
#include <sys/kmem.h>
#include <sys/errno.h>
#include <sys/bootconf.h>
#include <sys/archsystm.h>
#include <sys/fpu/fpusystm.h>
#include <sys/auxv.h>
#include <sys/debug.h>
#include <sys/elf.h>
#include <sys/elf_SPARC.h>
#include <sys/cmn_err.h>
#include <sys/spl.h>
#include <sys/privregs.h>
#include <sys/kobj.h>
#include <sys/modctl.h>
#include <sys/reboot.h>
#include <sys/time.h>
#include <sys/panic.h>
#include <vm/seg_kmem.h>
#include <vm/page.h>
#include <sys/machpcb.h>

extern struct bootops *bootops;

/*
 * Workaround for broken FDDI driver (remove when 4289172 is fixed)
 */
short cputype = 0x80;

extern int getpcstack_top(pc_t *pcstack, int limit, uintptr_t *lastfp,
    pc_t *lastpc);

/*
 * Get a pc-only stacktrace.  Used for kmem_alloc() buffer ownership tracking.
 * Returns MIN(current stack depth, pcstack_limit).
 */
int
getpcstack(pc_t *pcstack, int pcstack_limit)
{
	struct frame *fp, *minfp, *stacktop;
	uintptr_t nextfp;
	pc_t nextpc;
	int depth;
	int on_intr;
	pc_t pcswin[MAXWIN];
	int npcwin = MIN(MAXWIN, pcstack_limit);

	if ((on_intr = CPU_ON_INTR(CPU)) != 0)
		stacktop = (struct frame *)(CPU->cpu_intr_stack + SA(MINFRAME));
	else
		stacktop = (struct frame *)curthread->t_stk;

	minfp = (struct frame *)((uintptr_t)getfp() + STACK_BIAS);

	/*
	 * getpcstack_top() processes the frames still in register windows,
	 * fills nextfp and nextpc with our starting point, and returns
	 * the number of frames it wrote into pcstack.
	 *
	 * Since we cannot afford to take a relocation trap while we are
	 * messing with register windows, we pass getpcstack_top() a buffer
	 * on our stack and then copy the result out to the pcstack buffer
	 * provided by the caller.  The size of this buffer is the maximum
	 * supported number of SPARC register windows; however we ASSERT
	 * that it returns fewer than that, since it will skip the current
	 * frame.
	 */
	npcwin = getpcstack_top(pcswin, npcwin, &nextfp, &nextpc);
	ASSERT(npcwin >= 0 && npcwin < MAXWIN && npcwin <= pcstack_limit);
	for (depth = 0; depth < npcwin; depth++) {
		pcstack[depth] = pcswin[depth];
	}

	fp = (struct frame *)(nextfp + STACK_BIAS);

	while (depth < pcstack_limit) {
		if (fp <= minfp || fp >= stacktop) {
			if (on_intr) {
				/*
				 * Hop from interrupt stack to thread stack.
				 */
				stacktop = (struct frame *)curthread->t_stk;
				minfp = (struct frame *)curthread->t_stkbase;
				on_intr = 0;
				continue;
			}
			break;
		}

		pcstack[depth++] = nextpc;
		minfp = fp;

		nextpc = (pc_t)fp->fr_savpc;
		fp = (struct frame *)((uintptr_t)fp->fr_savfp + STACK_BIAS);
	}

	return (depth);
}

/*
 * The following ELF header fields are defined as processor-specific
 * in the SPARC V8 ABI:
 *
 *	e_ident[EI_DATA]	encoding of the processor-specific
 *				data in the object file
 *	e_machine		processor identification
 *	e_flags			processor-specific flags associated
 *				with the file
 */

/*
 * The value of at_flags reflects a platform's cpu module support.
 * at_flags is used to check for allowing a binary to execute and
 * is passed as the value of the AT_FLAGS auxiliary vector.
 */
int at_flags = 0;

/*
 * Check the processor-specific fields of an ELF header.
 *
 * returns 1 if the fields are valid, 0 otherwise
 */
int
elfheadcheck(
	unsigned char e_data,
	Elf32_Half e_machine,
	Elf32_Word e_flags)
{
	Elf32_Word needed_flags;
	int supported_flags;

	if (e_data != ELFDATA2MSB)
		return (0);

	switch (e_machine) {
	case EM_SPARC:
		if (e_flags == 0)
			return (1);
		else
			return (0);
	case EM_SPARCV9:
		/*
		 * Check that ELF flags are set to supported SPARC V9 flags
		 */
		needed_flags = e_flags & EF_SPARC_EXT_MASK;
		supported_flags = at_flags & ~EF_SPARC_32PLUS;

		if (needed_flags & ~supported_flags)
			return (0);
		else
			return (1);
	case EM_SPARC32PLUS:
		if ((e_flags & EF_SPARC_32PLUS) != 0 &&
		    ((e_flags & ~at_flags) & EF_SPARC_32PLUS_MASK) == 0)
			return (1);
		else
			return (0);
	default:
		return (0);
	}
}

uint_t auxv_hwcap_include = 0;	/* patch to enable unrecognized features */
uint_t auxv_hwcap_exclude = 0;	/* patch for broken cpus, debugging */
#if defined(_SYSCALL32_IMPL)
uint_t auxv_hwcap32_include = 0;	/* ditto for 32-bit apps */
uint_t auxv_hwcap32_exclude = 0;	/* ditto for 32-bit apps */
#endif

uint_t cpu_hwcap_flags = 0;	/* set by cpu-dependent code */

/*
 * Gather information about the processor and place it into auxv_hwcap
 * so that it can be exported to the linker via the aux vector.
 *
 * We use this seemingly complicated mechanism so that we can ensure
 * that /etc/system can be used to override what the system can or
 * cannot discover for itself.
 */
void
bind_hwcap(void)
{
	auxv_hwcap = (auxv_hwcap_include | cpu_hwcap_flags) &
	    ~auxv_hwcap_exclude;

	if (auxv_hwcap_include || auxv_hwcap_exclude)
		cmn_err(CE_CONT, "?user ABI extensions: %b\n",
		    auxv_hwcap, FMT_AV_SPARC);

#if defined(_SYSCALL32_IMPL)
	/*
	 * These are now a compatibility artifact; all supported SPARC CPUs
	 * are V9-capable (and thus support v8plus) and fully implement
	 * {s,u}mul and {s,u}div.
	 */
	cpu_hwcap_flags |= AV_SPARC_MUL32 | AV_SPARC_DIV32 | AV_SPARC_V8PLUS;

	auxv_hwcap32 = (auxv_hwcap32_include | cpu_hwcap_flags) &
	    ~auxv_hwcap32_exclude;

	if (auxv_hwcap32_include || auxv_hwcap32_exclude)
		cmn_err(CE_CONT, "?32-bit user ABI extensions: %b\n",
		    auxv_hwcap32, FMT_AV_SPARC);
#endif
}

int
__ipltospl(int ipl)
{
	return (ipltospl(ipl));
}

/*
 * Print a stack backtrace using the specified stack pointer.  We delay two
 * seconds before continuing, unless this is the panic traceback.
 * If we are in the process of panicking, we also attempt to write the
 * stack backtrace to a staticly assigned buffer, to allow the panic
 * code to find it and write it in to uncompressed pages within the
 * system crash dump.
 *
 * Note that the frame for the starting stack pointer value is omitted because
 * the corresponding %pc is not known.
 */

extern char *dump_stack_scratch;

void
traceback(caddr_t sp)
{
	struct frame *fp = (struct frame *)(sp + STACK_BIAS);
	struct frame *nextfp, *minfp, *stacktop;
	int on_intr;

	cpu_t *cpu;

	uint_t  offset = 0;
	uint_t  next_offset = 0;
	char    stack_buffer[2048];
	char    local_buffer[1024];

	flush_windows();

	if (!panicstr)
		printf("traceback: %%sp = %p\n", (void *)sp);

	if (panicstr && !dump_stack_scratch) {
		printf("Warning - stack not written to the dumpbuf\n");
	}

	/*
	 * If we are panicking, the high-level interrupt information in
	 * CPU was overwritten.  panic_cpu has the correct values.
	 */
	kpreempt_disable();			/* prevent migration */

	cpu = (panicstr && CPU->cpu_id == panic_cpu.cpu_id)? &panic_cpu : CPU;

	if ((on_intr = CPU_ON_INTR(cpu)) != 0)
		stacktop = (struct frame *)(cpu->cpu_intr_stack + SA(MINFRAME));
	else
		stacktop = (struct frame *)curthread->t_stk;

	kpreempt_enable();

	minfp = fp;

	while ((uintptr_t)fp >= KERNELBASE) {
		uintptr_t pc = (uintptr_t)fp->fr_savpc;
		ulong_t off;
		char *sym;

		nextfp = (struct frame *)((uintptr_t)fp->fr_savfp + STACK_BIAS);
		if (nextfp <= minfp || nextfp >= stacktop) {
			if (on_intr) {
				/*
				 * Hop from interrupt stack to thread stack.
				 */
				stacktop = (struct frame *)curthread->t_stk;
				minfp = (struct frame *)curthread->t_stkbase;
				on_intr = 0;
				continue;
			}
			break; /* we're outside of the expected range */
		}

		if ((uintptr_t)nextfp & (STACK_ALIGN - 1)) {
			printf("  >> mis-aligned %%fp = %p\n", (void *)nextfp);
			break;
		}

		if ((sym = kobj_getsymname(pc, &off)) != NULL) {
			printf("%016lx %s:%s+%lx "
			    "(%lx, %lx, %lx, %lx, %lx, %lx)\n", (ulong_t)nextfp,
			    mod_containing_pc((caddr_t)pc), sym, off,
			    nextfp->fr_arg[0], nextfp->fr_arg[1],
			    nextfp->fr_arg[2], nextfp->fr_arg[3],
			    nextfp->fr_arg[4], nextfp->fr_arg[5]);
			(void) snprintf(stack_buffer, sizeof (stack_buffer),
			    "%s:%s+%lx "
			    "(%lx, %lx, %lx, %lx, %lx, %lx) | ",
			    mod_containing_pc((caddr_t)pc), sym, off,
			    nextfp->fr_arg[0], nextfp->fr_arg[1],
			    nextfp->fr_arg[2], nextfp->fr_arg[3],
			    nextfp->fr_arg[4], nextfp->fr_arg[5]);
		} else {
			(void) printf("%016lx %p (%lx, %lx, %lx, "
			    "%lx, %lx, %lx)\n",
			    (ulong_t)nextfp, (void *)pc,
			    nextfp->fr_arg[0], nextfp->fr_arg[1],
			    nextfp->fr_arg[2], nextfp->fr_arg[3],
			    nextfp->fr_arg[4], nextfp->fr_arg[5]);
			(void) snprintf(stack_buffer, sizeof (stack_buffer),
			    "%p (%lx, %lx, %lx, %lx, %lx, %lx) | ",
			    (void *)pc,
			    nextfp->fr_arg[0], nextfp->fr_arg[1],
			    nextfp->fr_arg[2], nextfp->fr_arg[3],
			    nextfp->fr_arg[4], nextfp->fr_arg[5]);
		}

		(void) snprintf(local_buffer, sizeof (local_buffer),
		    "  %%l0-3: %016lx %016lx %016lx %016lx\n"
		    "  %%l4-7: %016lx %016lx %016lx %016lx\n",
		    nextfp->fr_local[0], nextfp->fr_local[1],
		    nextfp->fr_local[2], nextfp->fr_local[3],
		    nextfp->fr_local[4], nextfp->fr_local[5],
		    nextfp->fr_local[6], nextfp->fr_local[7]);
		if (panicstr && dump_stack_scratch) {
			next_offset = offset + strlen(stack_buffer);
			if (next_offset < STACK_BUF_SIZE) {
				bcopy(stack_buffer, dump_stack_scratch + offset,
				    strlen(stack_buffer));
				offset = next_offset;
			} else {
				/*
				 * In attempting to save the panic stack
				 * to the dumpbuf we have overflowed that area.
				 * Print a warning and continue to printf the
				 * stack to the msgbuf
				 */
				printf("Warning: stack in the dump buffer"
				    " may be incomplete\n");
			}
		}
		printf("%s", local_buffer);

		fp = nextfp;
		minfp = fp;
	}

	if (!panicstr) {
		printf("end of traceback\n");
		DELAY(2 * MICROSEC);
	} else if (dump_stack_scratch) {
		dump_stack_scratch[offset] = '\0';
	}
}

/*
 * Generate a stack backtrace from a saved register set.
 */
void
traceregs(struct regs *rp)
{
	traceback((caddr_t)rp->r_sp);
}

void
exec_set_sp(size_t stksize)
{
	klwp_t *lwp = ttolwp(curthread);

	lwp->lwp_pcb.pcb_xregstat = XREGNONE;
	if (curproc->p_model == DATAMODEL_NATIVE)
		stksize += sizeof (struct rwindow) + STACK_BIAS;
	else
		stksize += sizeof (struct rwindow32);
	lwptoregs(lwp)->r_sp = (uintptr_t)curproc->p_usrstack - stksize;
}

/*
 * Allocate a region of virtual address space, unmapped.
 *
 * When a hard-redzone (firewall) is in effect, redzone violations are
 * caught by the hardware the instant they happen because the first byte
 * past the logical end of a firewalled buffer lies at the start of an
 * unmapped page.  This firewalling is accomplished by bumping up the
 * requested address allocation, effectively removing an additional page
 * beyond the original request from the available virtual memory arena.
 * However, the size of the allocation passed to boot, in boot_alloc(),
 * doesn't reflect this additional page and fragmentation of the OBP
 * "virtual-memory" "available" lists property occurs.  Calling
 * prom_claim_virt() for the firewall page avoids this fragmentation.
 */
void *
boot_virt_alloc(void *addr, size_t size)
{
	return (BOP_ALLOC_VIRT((caddr_t)addr, size));
}


/*ARGSUSED*/
int
xcopyin_nta(const void *uaddr, void *kaddr, size_t count, int dummy)
{
	return (xcopyin(uaddr, kaddr, count));
}
/*ARGSUSED*/
int
xcopyout_nta(const void *kaddr, void *uaddr, size_t count, int dummy)
{
	return (xcopyout(kaddr, uaddr, count));
}
/*ARGSUSED*/
int
kcopy_nta(const void *from, void *to, size_t count, int dummy)
{
	return (kcopy(from, to, count));
}