Quelle  traps.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Kernel traps/events for Hexagon processor
 *
 * Copyright (c) 2010-2014, The Linux Foundation. All rights reserved.
 */

#include <linux/init.h>
#include <linux/sched/signal.h>
#include <linux/sched/debug.h>
#include <linux/sched/task_stack.h>
#include <linux/module.h>
#include <linux/kallsyms.h>
#include <linux/kdebug.h>
#include <linux/syscalls.h>
#include <linux/signal.h>
#include <linux/ptrace.h>
#include <asm/traps.h>
#include <asm/vm_fault.h>
#include <asm/syscall.h>
#include <asm/registers.h>
#include <asm/unistd.h>
#include <asm/sections.h>
#ifdef CONFIG_KGDB
# include <linux/kgdb.h>
#endif

#define TRAP_SYSCALL 1
#define TRAP_DEBUG 0xdb

#ifdef CONFIG_GENERIC_BUG
/* Maybe should resemble arch/sh/kernel/traps.c ?? */
int is_valid_bugaddr(unsigned long addr)
{
 return 1;
}
#endif /* CONFIG_GENERIC_BUG */

static const char *ex_name(int ex)
{
 switch (ex) {
 case HVM_GE_C_XPROT:
 case HVM_GE_C_XUSER:
  return "Execute protection fault";
 case HVM_GE_C_RPROT:
 case HVM_GE_C_RUSER:
  return "Read protection fault";
 case HVM_GE_C_WPROT:
 case HVM_GE_C_WUSER:
  return "Write protection fault";
 case HVM_GE_C_XMAL:
  return "Misaligned instruction";
 case HVM_GE_C_WREG:
  return "Multiple writes to same register in packet";
 case HVM_GE_C_PCAL:
  return "Program counter values that are not properly aligned";
 case HVM_GE_C_RMAL:
  return "Misaligned data load";
 case HVM_GE_C_WMAL:
  return "Misaligned data store";
 case HVM_GE_C_INVI:
 case HVM_GE_C_PRIVI:
  return "Illegal instruction";
 case HVM_GE_C_BUS:
  return "Precise bus error";
 case HVM_GE_C_CACHE:
  return "Cache error";

 case 0xdb:
  return "Debugger trap";

 default:
  return "Unrecognized exception";
 }
}

static void do_show_stack(struct task_struct *task, unsigned long *fp,
     unsigned long ip, const char *loglvl)
{
 int kstack_depth_to_print = 24;
 unsigned long offset, size;
 const char *name = NULL;
 unsigned long *newfp;
 unsigned long low, high;
 char tmpstr[128];
 char *modname;
 int i;

 if (task == NULL)
  task = current;

 printk("%sCPU#%d, %s/%d, Call Trace:\n", loglvl, raw_smp_processor_id(),
  task->comm, task_pid_nr(task));

 if (fp == NULL) {
  if (task == current) {
   asm("%0 = r30" : "=r" (fp));
  } else {
   fp = (unsigned long *)
        ((struct hexagon_switch_stack *)
        task->thread.switch_sp)->fp;
  }
 }

 if ((((unsigned long) fp) & 0x3) || ((unsigned long) fp < 0x1000)) {
  printk("%s-- Corrupt frame pointer %p\n", loglvl, fp);
  return;
 }

 /* Saved link reg is one word above FP */
 if (!ip)
  ip = *(fp+1);

 /* Expect kernel stack to be in-bounds */
 low = (unsigned long)task_stack_page(task);
 high = low + THREAD_SIZE - 8;
 low += sizeof(struct thread_info);

 for (i = 0; i < kstack_depth_to_print; i++) {

  name = kallsyms_lookup(ip, &size, &offset, &modname, tmpstr);

  printk("%s[%p] 0x%lx: %s + 0x%lx", loglvl, fp, ip, name, offset);
  if (((unsigned long) fp < low) || (high < (unsigned long) fp))
   printk(KERN_CONT " (FP out of bounds!)");
  if (modname)
   printk(KERN_CONT " [%s] ", modname);
  printk(KERN_CONT "\n");

  newfp = (unsigned long *) *fp;

  if (((unsigned long) newfp) & 0x3) {
   printk("%s-- Corrupt frame pointer %p\n", loglvl, newfp);
   break;
  }

  /* Attempt to continue past exception. */
  if (!newfp) {
   struct pt_regs *regs = (struct pt_regs *) (((void *)fp)
      + 8);

   if (regs->syscall_nr != -1) {
    printk("%s-- trap0 -- syscall_nr: %ld", loglvl,
     regs->syscall_nr);
    printk(KERN_CONT " psp: %lx elr: %lx\n",
      pt_psp(regs), pt_elr(regs));
    break;
   } else {
    /* really want to see more ... */
    kstack_depth_to_print += 6;
    printk("%s-- %s (0x%lx) badva: %lx\n", loglvl,
     ex_name(pt_cause(regs)), pt_cause(regs),
     pt_badva(regs));
   }

   newfp = (unsigned long *) regs->r30;
   ip = pt_elr(regs);
  } else {
   ip = *(newfp + 1);
  }

  /* If link reg is null, we are done. */
  if (ip == 0x0)
   break;

  /* If newfp isn't larger, we're tracing garbage. */
  if (newfp > fp)
   fp = newfp;
  else
   break;
 }
}

void show_stack(struct task_struct *task, unsigned long *fp, const char *loglvl)
{
 /* Saved link reg is one word above FP */
 do_show_stack(task, fp, 0, loglvl);
}

int die(const char *str, struct pt_regs *regs, long err)
{
 static struct {
  spinlock_t lock;
  int counter;
 } die = {
  .lock = __SPIN_LOCK_UNLOCKED(die.lock),
  .counter = 0
 };

 console_verbose();
 oops_enter();

 spin_lock_irq(&die.lock);
 bust_spinlocks(1);
 printk(KERN_EMERG "Oops: %s[#%d]:\n", str, ++die.counter);

 if (notify_die(DIE_OOPS, str, regs, err, pt_cause(regs), SIGSEGV) ==
     NOTIFY_STOP) {
  spin_unlock_irq(&die.lock);
  return 1;
 }

 print_modules();
 show_regs(regs);
 do_show_stack(current, ®s->r30, pt_elr(regs), KERN_EMERG);

 bust_spinlocks(0);
 add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);

 spin_unlock_irq(&die.lock);

 if (in_interrupt())
  panic("Fatal exception in interrupt");

 if (panic_on_oops)
  panic("Fatal exception");

 oops_exit();
 make_task_dead(err);
 return 0;
}

int die_if_kernel(char *str, struct pt_regs *regs, long err)
{
 if (!user_mode(regs))
  return die(str, regs, err);
 else
  return 0;
}

/*
 * It's not clear that misaligned fetches are ever recoverable.
 */
static void misaligned_instruction(struct pt_regs *regs)
{
 die_if_kernel("Misaligned Instruction", regs, 0);
 force_sig(SIGBUS);
}

/*
 * Misaligned loads and stores, on the other hand, can be
 * emulated, and probably should be, some day.  But for now
 * they will be considered fatal.
 */
static void misaligned_data_load(struct pt_regs *regs)
{
 die_if_kernel("Misaligned Data Load", regs, 0);
 force_sig(SIGBUS);
}

static void misaligned_data_store(struct pt_regs *regs)
{
 die_if_kernel("Misaligned Data Store", regs, 0);
 force_sig(SIGBUS);
}

static void illegal_instruction(struct pt_regs *regs)
{
 die_if_kernel("Illegal Instruction", regs, 0);
 force_sig(SIGILL);
}

/*
 * Precise bus errors may be recoverable with a a retry,
 * but for now, treat them as irrecoverable.
 */
static void precise_bus_error(struct pt_regs *regs)
{
 die_if_kernel("Precise Bus Error", regs, 0);
 force_sig(SIGBUS);
}

/*
 * If anything is to be done here other than panic,
 * it will probably be complex and migrate to another
 * source module.  For now, just die.
 */
static void cache_error(struct pt_regs *regs)
{
 die("Cache Error", regs, 0);
}

/*
 * General exception handler
 */
void do_genex(struct pt_regs *regs);
void do_genex(struct pt_regs *regs)
{
 /*
 * Decode Cause and Dispatch
 */
 switch (pt_cause(regs)) {
 case HVM_GE_C_XPROT:
 case HVM_GE_C_XUSER:
  execute_protection_fault(regs);
  break;
 case HVM_GE_C_RPROT:
 case HVM_GE_C_RUSER:
  read_protection_fault(regs);
  break;
 case HVM_GE_C_WPROT:
 case HVM_GE_C_WUSER:
  write_protection_fault(regs);
  break;
 case HVM_GE_C_XMAL:
  misaligned_instruction(regs);
  break;
 case HVM_GE_C_WREG:
  illegal_instruction(regs);
  break;
 case HVM_GE_C_PCAL:
  misaligned_instruction(regs);
  break;
 case HVM_GE_C_RMAL:
  misaligned_data_load(regs);
  break;
 case HVM_GE_C_WMAL:
  misaligned_data_store(regs);
  break;
 case HVM_GE_C_INVI:
 case HVM_GE_C_PRIVI:
  illegal_instruction(regs);
  break;
 case HVM_GE_C_BUS:
  precise_bus_error(regs);
  break;
 case HVM_GE_C_CACHE:
  cache_error(regs);
  break;
 default:
  /* Halt and catch fire */
  panic("Unrecognized exception 0x%lx\n", pt_cause(regs));
  break;
 }
}

void do_trap0(struct pt_regs *regs);
void do_trap0(struct pt_regs *regs)
{
 syscall_fn syscall;

 switch (pt_cause(regs)) {
 case TRAP_SYSCALL:
  /* System call is trap0 #1 */

  /* allow strace to catch syscall args  */
  if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE) &&
   ptrace_report_syscall_entry(regs)))
   return;  /*  return -ENOSYS somewhere?  */

  /* Interrupts should be re-enabled for syscall processing */
  __vmsetie(VM_INT_ENABLE);

  /*
 * System call number is in r6, arguments in r0..r5.
 * Fortunately, no Linux syscall has more than 6 arguments,
 * and Hexagon ABI passes first 6 arguments in registers.
 * 64-bit arguments are passed in odd/even register pairs.
 * Fortunately, we have no system calls that take more
 * than three arguments with more than one 64-bit value.
 * Should that change, we'd need to redesign to copy
 * between user and kernel stacks.
 */
  regs->syscall_nr = regs->r06;

  /*
 * GPR R0 carries the first parameter, and is also used
 * to report the return value.  We need a backup of
 * the user's value in case we need to do a late restart
 * of the system call.
 */
  regs->restart_r0 = regs->r00;

  if ((unsigned long) regs->syscall_nr >= __NR_syscalls) {
   regs->r00 = -1;
  } else {
   syscall = (syscall_fn)
      (sys_call_table[regs->syscall_nr]);
   regs->r00 = syscall(regs->r00, regs->r01,
       regs->r02, regs->r03,
       regs->r04, regs->r05);
  }

  /* allow strace to get the syscall return state  */
  if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE)))
   ptrace_report_syscall_exit(regs, 0);

  break;
 case TRAP_DEBUG:
  /* Trap0 0xdb is debug breakpoint */
  if (user_mode(regs)) {
   /*
 * Some architecures add some per-thread state
 * to distinguish between breakpoint traps and
 * trace traps.  We may want to do that, and
 * set the si_code value appropriately, or we
 * may want to use a different trap0 flavor.
 */
   force_sig_fault(SIGTRAP, TRAP_BRKPT,
     (void __user *) pt_elr(regs));
  } else {
#ifdef CONFIG_KGDB
   kgdb_handle_exception(pt_cause(regs), SIGTRAP,
           TRAP_BRKPT, regs);
#endif
  }
  break;
 }
 /* Ignore other trap0 codes for now, especially 0 (Angel calls) */
}

/*
 * Machine check exception handler
 */
void do_machcheck(struct pt_regs *regs);
void do_machcheck(struct pt_regs *regs)
{
 /* Halt and catch fire */
 __vmstop();
}

/*
 * Treat this like the old 0xdb trap.
 */

void do_debug_exception(struct pt_regs *regs);
void do_debug_exception(struct pt_regs *regs)
{
 regs->hvmer.vmest &= ~HVM_VMEST_CAUSE_MSK;
 regs->hvmer.vmest |= (TRAP_DEBUG << HVM_VMEST_CAUSE_SFT);
 do_trap0(regs);
}