Quelle  traps.c   Sprache: C

/*
 * Hardware exception handling
 *
 * Copyright (C) 2010 Tobias Klauser <tklauser@distanz.ch>
 * Copyright (C) 2004 Microtronix Datacom Ltd.
 * Copyright (C) 2001 Vic Phillips
 *
 * This file is subject to the terms and conditions of the GNU General
 * Public License.  See the file COPYING in the main directory of this
 * archive for more details.
 */

#include <linux/sched.h>
#include <linux/sched/debug.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/export.h>
#include <linux/mm.h>
#include <linux/ptrace.h>

#include <asm/traps.h>
#include <asm/sections.h>
#include <linux/uaccess.h>

static DEFINE_SPINLOCK(die_lock);

static void _send_sig(int signo, int code, unsigned long addr)
{
 force_sig_fault(signo, code, (void __user *) addr);
}

void die(const char *str, struct pt_regs *regs, long err)
{
 console_verbose();
 spin_lock_irq(&die_lock);
 pr_warn("Oops: %s, sig: %ld\n", str, err);
 show_regs(regs);
 spin_unlock_irq(&die_lock);
 /*
  * make_task_dead() should take care of panic'ing from an interrupt
  * context so we don't handle it here
 */
 make_task_dead(err);
}

void _exception(int signo, struct pt_regs *regs, int code, unsigned long addr)
{
 if (!user_mode(regs))
  die("Exception in kernel mode", regs, signo);

 _send_sig(signo, code, addr);
}

/*
 * The show_stack() is external API which we do not use ourselves.
 */

int kstack_depth_to_print = 48;

void show_stack(struct task_struct *task, unsigned long *stack,
  const char *loglvl)
{
 unsigned long *endstack, addr;
 int i;

 if (!stack) {
  if (task)
   stack = (unsigned long *)task->thread.ksp;
  else
   stack = (unsigned long *)&stack;
 }

 addr = (unsigned long) stack;
 endstack = (unsigned long *) PAGE_ALIGN(addr);

 printk("%sStack from %08lx:", loglvl, (unsigned long)stack);
 for (i = 0; i < kstack_depth_to_print; i++) {
  if (stack + 1 > endstack)
   break;
  if (i % 8 == 0)
   printk("%s\n       ", loglvl);
  printk("%s %08lx", loglvl, *stack++);
 }

 printk("%s\nCall Trace:", loglvl);
 i = 0;
 while (stack + 1 <= endstack) {
  addr = *stack++;
  /*
   * If the address is either in the text segment of the
   * kernel, or in the region which contains vmalloc'ed
   * memory, it *may* be the address of a calling
   * routine; if so, print it so that someone tracing
   * down the cause of the crash will be able to figure
   * out the call path that was taken.
 */
  if (((addr >= (unsigned long) _stext) &&
       (addr <= (unsigned long) _etext))) {
   if (i % 4 == 0)
    pr_emerg("\n       ");
   printk("%s [<%08lx>]", loglvl, addr);
   i++;
  }
 }
 printk("%s\n", loglvl);
}

/* Breakpoint handler */
asmlinkage void breakpoint_c(struct pt_regs *fp)
{
 /*
  * The breakpoint entry code has moved the PC on by 4 bytes, so we must
  * move it back. This could be done on the host but we do it here
  * because monitor.S of JTAG gdbserver does it too.
 */
 fp->ea -= 4;
 _exception(SIGTRAP, fp, TRAP_BRKPT, fp->ea);
}

#ifndef CONFIG_NIOS2_ALIGNMENT_TRAP
/* Alignment exception handler */
asmlinkage void handle_unaligned_c(struct pt_regs *fp, int cause)
{
 unsigned long addr = RDCTL(CTL_BADADDR);

 cause >>= 2;
 fp->ea -= 4;

 if (fixup_exception(fp))
  return;

 if (!user_mode(fp)) {
  pr_alert("Unaligned access from kernel mode, this might be a hardware\n");
  pr_alert("problem, dump registers and restart the instruction\n");
  pr_alert("  BADADDR 0x%08lx\n", addr);
  pr_alert("  cause   %d\n", cause);
  pr_alert("  op-code 0x%08lx\n", *(unsigned long *)(fp->ea));
  show_regs(fp);
  return;
 }

 _exception(SIGBUS, fp, BUS_ADRALN, addr);
}
#endif /* CONFIG_NIOS2_ALIGNMENT_TRAP */

/* Illegal instruction handler */
asmlinkage void handle_illegal_c(struct pt_regs *fp)
{
 fp->ea -= 4;
 _exception(SIGILL, fp, ILL_ILLOPC, fp->ea);
}

/* Supervisor instruction handler */
asmlinkage void handle_supervisor_instr(struct pt_regs *fp)
{
 fp->ea -= 4;
 _exception(SIGILL, fp, ILL_PRVOPC, fp->ea);
}

/* Division error handler */
asmlinkage void handle_diverror_c(struct pt_regs *fp)
{
 fp->ea -= 4;
 _exception(SIGFPE, fp, FPE_INTDIV, fp->ea);
}

/* Unhandled exception handler */
asmlinkage void unhandled_exception(struct pt_regs *regs, int cause)
{
 unsigned long addr = RDCTL(CTL_BADADDR);

 cause /= 4;

 pr_emerg("Unhandled exception #%d in %s mode (badaddr=0x%08lx)\n",
   cause, user_mode(regs) ? "user" : "kernel", addr);

 regs->ea -= 4;
 show_regs(regs);

 pr_emerg("opcode: 0x%08lx\n", *(unsigned long *)(regs->ea));
}

asmlinkage void handle_trap_1_c(struct pt_regs *fp)
{
 _send_sig(SIGUSR1, 0, fp->ea);
}

asmlinkage void handle_trap_2_c(struct pt_regs *fp)
{
 _send_sig(SIGUSR2, 0, fp->ea);
}

asmlinkage void handle_trap_3_c(struct pt_regs *fp)
{
 _send_sig(SIGILL, ILL_ILLTRP, fp->ea);
}