NetBSD/sys/arch/arm32/arm32/undefined.c

/*	$NetBSD: undefined.c,v 1.14 1998/07/07 17:51:55 mark Exp $	*/

/*
 * Copyright (c) 1995 Mark Brinicombe.
 * Copyright (c) 1995 Brini.
 * All rights reserved.
 *
 * This code is derived from software written for Brini by Mark Brinicombe
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by Brini.
 * 4. The name of the company nor the name of the author may be used to
 *    endorse or promote products derived from this software without specific
 *    prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY BRINI ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL BRINI OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * RiscBSD kernel project
 *
 * undefined.c
 *
 * Fault handler
 *
 * Created      : 06/01/95
 */

#define FAST_FPE

#include "opt_ddb.h"
#include "opt_uvm.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/user.h>
#include <sys/syslog.h>
#include <sys/vmmeter.h>
#ifdef FAST_FPE
#include <sys/acct.h>
#endif

#if defined(UVM)
#include <vm/vm.h>
#include <uvm/uvm_extern.h>
#endif

#include <machine/cpu.h>
#include <machine/frame.h>
#include <machine/katelib.h>
#include <machine/undefined.h>
#include <machine/trap.h>

#include <arm32/arm32/disassem.h>

#ifdef FAST_FPE
extern int want_resched;
#endif

undef_handler_t undefined_handlers[MAX_COPROCS];

int
default_undefined_handler(address, instruction, frame, fault_code)
	u_int address;
	u_int instruction;
	trapframe_t *frame;
	int fault_code;
{
	struct proc *p;

	p = curproc;
	if (p == NULL)
		p = &proc0;
	log(LOG_ERR, "Undefined instruction 0x%08x @ 0x%08x in process %s (pid %d)\n",
	    instruction, address, p->p_comm, p->p_pid);
	return(1);
}


int
install_coproc_handler(coproc, handler)
	int coproc;
	undef_handler_t handler;
{
	if (coproc < 0 || coproc > MAX_COPROCS)
		return(EINVAL);
	if (handler == (undef_handler_t)0)
		handler = default_undefined_handler;
      
	undefined_handlers[coproc] = handler;
	return(0);
}


void
undefined_init()
{
	int loop;

	for (loop = 0; loop < MAX_COPROCS; ++loop)
		undefined_handlers[loop] = default_undefined_handler;
}


void
undefinedinstruction(frame)
	trapframe_t *frame;
{
	struct proc *p;
	u_int fault_pc;
	int fault_instruction;
	int s;
	int fault_code;
	u_quad_t sticks = 0;
	int coprocessor;

	/* Enable interrupts if they were enabled before the exception. */
	if (!(frame->tf_spsr & I32_bit))
		enable_interrupts(I32_bit);

	/* Update vmmeter statistics */
#if defined(UVM)
	uvmexp.traps++;
#else
    	cnt.v_trap++;
#endif

	fault_pc = frame->tf_pc - INSN_SIZE;

	/*
	 * Should use fuword() here .. but in the interests of squeezing every
	 * bit of speed we will just use ReadWord(). We know the instruction
	 * can be read as was just executed so this will never fail unless the
	 * kernel is screwed up in which case it does not really matter does
	 * it ?
	 */

	fault_instruction = ReadWord(fault_pc);

	/* Check for coprocessor instruction */

	/*
	 * According to the datasheets you only need to look at bit 27 of the
	 * instruction to tell the difference between and undefined
	 * instruction and a coprocessor instruction following an undefined
	 * instruction trap.
	 */

	if ((fault_instruction & (1 << 27)) != 0)
		coprocessor = (fault_instruction >> 8) & 0x0f;
	else
		coprocessor = 0;
		
	/* Get the current proc structure or proc0 if there is none */

	if ((p = curproc) == 0)
		p = &proc0;

	if ((frame->tf_spsr & PSR_MODE) == PSR_USR32_MODE) {
		sticks = p->p_sticks;
                  
	/* Modify the fault_code to reflect the USR/SVC state at time of fault */

		fault_code = FAULT_USER;
		p->p_md.md_regs = frame;
	} else
		fault_code = 0;

	/* OK this is were we do something about the instruction */
	/* Check for coprocessor instruction */

	/* Special cases */

	if (coprocessor == 0 && fault_instruction == GDB_BREAKPOINT
	    && fault_code == FAULT_USER) {
		frame->tf_pc -= INSN_SIZE;	/* Adjust to point to the BP */
		trapsignal(curproc, SIGTRAP, 0);
	} else if ((undefined_handlers[coprocessor](fault_pc, fault_instruction,
	    frame, fault_code)) != 0) {
		/* Fault has not been handled */

		s = spltty();

		if ((fault_instruction & 0x0f000010) == 0x0e000000) {
			printf("CDP\n");
			disassemble(fault_pc);
		}
		else if ((fault_instruction & 0x0e000000) == 0x0c000000) {
			printf("LDC/STC\n");
			disassemble(fault_pc);
		}
		else if ((fault_instruction & 0x0f000010) == 0x0e000010) {
			printf("MRC/MCR\n");
			disassemble(fault_pc);
		}
		else if ((fault_instruction & ~INSN_COND_MASK)
		    != (KERNEL_BREAKPOINT & ~INSN_COND_MASK)) {
			printf("Undefined instruction\n");
			disassemble(fault_pc);
		}

		(void)splx(s);
        
		if ((fault_code & FAULT_USER) == 0) {
			printf("Undefined instruction in kernel: Heavy man !\n");
#ifdef DDB
			Debugger();
#endif	/* DDB */
		}

		trapsignal(p, SIGILL, fault_instruction);
	}

	if ((fault_code & FAULT_USER) == 0)
		return;

#ifdef FAST_FPE
	/* Optimised exit code */
	{
		int sig;

		/* take pending signals */

		while ((sig = (CURSIG(p))) != 0) {
			postsig(sig);
		}

		p->p_priority = p->p_usrpri;

		/*
		 * Check for reschedule request, at the moment there is only
		 * 1 ast so this code should always be run
		 */

		if (want_resched) {
			/*
			 * Since we are curproc, a clock interrupt could
			 * change our priority without changing run queues
			 * (the running process is not kept on a run queue).
			 * If this happened after we setrunqueue ourselves but
			 * before we switch()'ed, we might not be on the queue
			 * indicated by our priority
			 */
	
		        s = splstatclock();
			setrunqueue(p);
			p->p_stats->p_ru.ru_nivcsw++;

			mi_switch();

			(void)splx(s);
			while ((sig = (CURSIG(p))) != 0) {
				postsig(sig);
			}
		}

		/*
		 * The profiling bit is commented out at the moment. This
		 * can be reinstated later on. Currently addupc_task is
		 * not written.
		 */

		if (p->p_flag & P_PROFIL) {
			extern int psratio;
			addupc_task(p, frame->tf_pc,
			    (int)(p->p_sticks - sticks) * psratio);
		}

		curpriority = p->p_priority;
	}

#else
	userret(p, frame->tf_pc, sticks);
#endif
}


void
resethandler(frame)
	trapframe_t *frame;
{
#ifdef DDB
	/* Extra info incase panic drops us into the debugger */
	printf("Trap frame at %p\n", frame);
#endif	/* DDB */
	panic("Branch to never-never land (zero)..... were dead\n");
}

/* End of undefined.c */