arch/hexagon/kernel/traps.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Kernel traps/events for Hexagon processor
   4  *
   5  * Copyright (c) 2010-2014, The Linux Foundation. All rights reserved.
   6  */
   7
   8 #include <linux/init.h>
   9 #include <linux/sched/signal.h>
  10 #include <linux/sched/debug.h>
  11 #include <linux/sched/task_stack.h>
  12 #include <linux/module.h>
  13 #include <linux/kallsyms.h>
  14 #include <linux/kdebug.h>
  15 #include <linux/syscalls.h>
  16 #include <linux/signal.h>
  17 #include <linux/tracehook.h>
  18 #include <asm/traps.h>
  19 #include <asm/vm_fault.h>
  20 #include <asm/syscall.h>
  21 #include <asm/registers.h>
  22 #include <asm/unistd.h>
  23 #include <asm/sections.h>
  24 #ifdef CONFIG_KGDB
  25 # include <linux/kgdb.h>
  26 #endif
  27
  28 #define TRAP_SYSCALL    1
  29 #define TRAP_DEBUG      0xdb
  30
  31 void __init trap_init(void)
  32 {
  33 }
  34
  35 #ifdef CONFIG_GENERIC_BUG
  36 /* Maybe should resemble arch/sh/kernel/traps.c ?? */
  37 int is_valid_bugaddr(unsigned long addr)
  38 {
  39         return 1;
  40 }
  41 #endif /* CONFIG_GENERIC_BUG */
  42
  43 static const char *ex_name(int ex)
  44 {
  45         switch (ex) {
  46         case HVM_GE_C_XPROT:
  47         case HVM_GE_C_XUSER:
  48                 return "Execute protection fault";
  49         case HVM_GE_C_RPROT:
  50         case HVM_GE_C_RUSER:
  51                 return "Read protection fault";
  52         case HVM_GE_C_WPROT:
  53         case HVM_GE_C_WUSER:
  54                 return "Write protection fault";
  55         case HVM_GE_C_XMAL:
  56                 return "Misaligned instruction";
  57         case HVM_GE_C_WREG:
  58                 return "Multiple writes to same register in packet";
  59         case HVM_GE_C_PCAL:
  60                 return "Program counter values that are not properly aligned";
  61         case HVM_GE_C_RMAL:
  62                 return "Misaligned data load";
  63         case HVM_GE_C_WMAL:
  64                 return "Misaligned data store";
  65         case HVM_GE_C_INVI:
  66         case HVM_GE_C_PRIVI:
  67                 return "Illegal instruction";
  68         case HVM_GE_C_BUS:
  69                 return "Precise bus error";
  70         case HVM_GE_C_CACHE:
  71                 return "Cache error";
  72
  73         case 0xdb:
  74                 return "Debugger trap";
  75
  76         default:
  77                 return "Unrecognized exception";
  78         }
  79 }
  80
  81 static void do_show_stack(struct task_struct *task, unsigned long *fp,
  82                           unsigned long ip, const char *loglvl)
  83 {
  84         int kstack_depth_to_print = 24;
  85         unsigned long offset, size;
  86         const char *name = NULL;
  87         unsigned long *newfp;
  88         unsigned long low, high;
  89         char tmpstr[128];
  90         char *modname;
  91         int i;
  92
  93         if (task == NULL)
  94                 task = current;
  95
  96         printk("%sCPU#%d, %s/%d, Call Trace:\n", loglvl, raw_smp_processor_id(),
  97                 task->comm, task_pid_nr(task));
  98
  99         if (fp == NULL) {
 100                 if (task == current) {
 101                         asm("%0 = r30" : "=r" (fp));
 102                 } else {
 103                         fp = (unsigned long *)
 104                              ((struct hexagon_switch_stack *)
 105                              task->thread.switch_sp)->fp;
 106                 }
 107         }
 108
 109         if ((((unsigned long) fp) & 0x3) || ((unsigned long) fp < 0x1000)) {
 110                 printk("%s-- Corrupt frame pointer %p\n", loglvl, fp);
 111                 return;
 112         }
 113
 114         /* Saved link reg is one word above FP */
 115         if (!ip)
 116                 ip = *(fp+1);
 117
 118         /* Expect kernel stack to be in-bounds */
 119         low = (unsigned long)task_stack_page(task);
 120         high = low + THREAD_SIZE - 8;
 121         low += sizeof(struct thread_info);
 122
 123         for (i = 0; i < kstack_depth_to_print; i++) {
 124
 125                 name = kallsyms_lookup(ip, &size, &offset, &modname, tmpstr);
 126
 127                 printk("%s[%p] 0x%lx: %s + 0x%lx", loglvl, fp, ip, name, offset);
 128                 if (((unsigned long) fp < low) || (high < (unsigned long) fp))
 129                         printk(KERN_CONT " (FP out of bounds!)");
 130                 if (modname)
 131                         printk(KERN_CONT " [%s] ", modname);
 132                 printk(KERN_CONT "\n");
 133
 134                 newfp = (unsigned long *) *fp;
 135
 136                 if (((unsigned long) newfp) & 0x3) {
 137                         printk("%s-- Corrupt frame pointer %p\n", loglvl, newfp);
 138                         break;
 139                 }
 140
 141                 /* Attempt to continue past exception. */
 142                 if (0 == newfp) {
 143                         struct pt_regs *regs = (struct pt_regs *) (((void *)fp)
 144                                                 + 8);
 145
 146                         if (regs->syscall_nr != -1) {
 147                                 printk("%s-- trap0 -- syscall_nr: %ld", loglvl,
 148                                         regs->syscall_nr);
 149                                 printk(KERN_CONT "  psp: %lx  elr: %lx\n",
 150                                          pt_psp(regs), pt_elr(regs));
 151                                 break;
 152                         } else {
 153                                 /* really want to see more ... */
 154                                 kstack_depth_to_print += 6;
 155                                 printk("%s-- %s (0x%lx)  badva: %lx\n", loglvl,
 156                                         ex_name(pt_cause(regs)), pt_cause(regs),
 157                                         pt_badva(regs));
 158                         }
 159
 160                         newfp = (unsigned long *) regs->r30;
 161                         ip = pt_elr(regs);
 162                 } else {
 163                         ip = *(newfp + 1);
 164                 }
 165
 166                 /* If link reg is null, we are done. */
 167                 if (ip == 0x0)
 168                         break;
 169
 170                 /* If newfp isn't larger, we're tracing garbage. */
 171                 if (newfp > fp)
 172                         fp = newfp;
 173                 else
 174                         break;
 175         }
 176 }
 177
 178 void show_stack(struct task_struct *task, unsigned long *fp, const char *loglvl)
 179 {
 180         /* Saved link reg is one word above FP */
 181         do_show_stack(task, fp, 0, loglvl);
 182 }
 183
 184 int die(const char *str, struct pt_regs *regs, long err)
 185 {
 186         static struct {
 187                 spinlock_t lock;
 188                 int counter;
 189         } die = {
 190                 .lock = __SPIN_LOCK_UNLOCKED(die.lock),
 191                 .counter = 0
 192         };
 193
 194         console_verbose();
 195         oops_enter();
 196
 197         spin_lock_irq(&die.lock);
 198         bust_spinlocks(1);
 199         printk(KERN_EMERG "Oops: %s[#%d]:\n", str, ++die.counter);
 200
 201         if (notify_die(DIE_OOPS, str, regs, err, pt_cause(regs), SIGSEGV) ==
 202             NOTIFY_STOP)
 203                 return 1;
 204
 205         print_modules();
 206         show_regs(regs);
 207         do_show_stack(current, &regs->r30, pt_elr(regs), KERN_EMERG);
 208
 209         bust_spinlocks(0);
 210         add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
 211
 212         spin_unlock_irq(&die.lock);
 213
 214         if (in_interrupt())
 215                 panic("Fatal exception in interrupt");
 216
 217         if (panic_on_oops)
 218                 panic("Fatal exception");
 219
 220         oops_exit();
 221         do_exit(err);
 222         return 0;
 223 }
 224
 225 int die_if_kernel(char *str, struct pt_regs *regs, long err)
 226 {
 227         if (!user_mode(regs))
 228                 return die(str, regs, err);
 229         else
 230                 return 0;
 231 }
 232
 233 /*
 234  * It's not clear that misaligned fetches are ever recoverable.
 235  */
 236 static void misaligned_instruction(struct pt_regs *regs)
 237 {
 238         die_if_kernel("Misaligned Instruction", regs, 0);
 239         force_sig(SIGBUS);
 240 }
 241
 242 /*
 243  * Misaligned loads and stores, on the other hand, can be
 244  * emulated, and probably should be, some day.  But for now
 245  * they will be considered fatal.
 246  */
 247 static void misaligned_data_load(struct pt_regs *regs)
 248 {
 249         die_if_kernel("Misaligned Data Load", regs, 0);
 250         force_sig(SIGBUS);
 251 }
 252
 253 static void misaligned_data_store(struct pt_regs *regs)
 254 {
 255         die_if_kernel("Misaligned Data Store", regs, 0);
 256         force_sig(SIGBUS);
 257 }
 258
 259 static void illegal_instruction(struct pt_regs *regs)
 260 {
 261         die_if_kernel("Illegal Instruction", regs, 0);
 262         force_sig(SIGILL);
 263 }
 264
 265 /*
 266  * Precise bus errors may be recoverable with a a retry,
 267  * but for now, treat them as irrecoverable.
 268  */
 269 static void precise_bus_error(struct pt_regs *regs)
 270 {
 271         die_if_kernel("Precise Bus Error", regs, 0);
 272         force_sig(SIGBUS);
 273 }
 274
 275 /*
 276  * If anything is to be done here other than panic,
 277  * it will probably be complex and migrate to another
 278  * source module.  For now, just die.
 279  */
 280 static void cache_error(struct pt_regs *regs)
 281 {
 282         die("Cache Error", regs, 0);
 283 }
 284
 285 /*
 286  * General exception handler
 287  */
 288 void do_genex(struct pt_regs *regs)
 289 {
 290         /*
 291          * Decode Cause and Dispatch
 292          */
 293         switch (pt_cause(regs)) {
 294         case HVM_GE_C_XPROT:
 295         case HVM_GE_C_XUSER:
 296                 execute_protection_fault(regs);
 297                 break;
 298         case HVM_GE_C_RPROT:
 299         case HVM_GE_C_RUSER:
 300                 read_protection_fault(regs);
 301                 break;
 302         case HVM_GE_C_WPROT:
 303         case HVM_GE_C_WUSER:
 304                 write_protection_fault(regs);
 305                 break;
 306         case HVM_GE_C_XMAL:
 307                 misaligned_instruction(regs);
 308                 break;
 309         case HVM_GE_C_WREG:
 310                 illegal_instruction(regs);
 311                 break;
 312         case HVM_GE_C_PCAL:
 313                 misaligned_instruction(regs);
 314                 break;
 315         case HVM_GE_C_RMAL:
 316                 misaligned_data_load(regs);
 317                 break;
 318         case HVM_GE_C_WMAL:
 319                 misaligned_data_store(regs);
 320                 break;
 321         case HVM_GE_C_INVI:
 322         case HVM_GE_C_PRIVI:
 323                 illegal_instruction(regs);
 324                 break;
 325         case HVM_GE_C_BUS:
 326                 precise_bus_error(regs);
 327                 break;
 328         case HVM_GE_C_CACHE:
 329                 cache_error(regs);
 330                 break;
 331         default:
 332                 /* Halt and catch fire */
 333                 panic("Unrecognized exception 0x%lx\n", pt_cause(regs));
 334                 break;
 335         }
 336 }
 337
 338 /* Indirect system call dispatch */
 339 long sys_syscall(void)
 340 {
 341         printk(KERN_ERR "sys_syscall invoked!\n");
 342         return -ENOSYS;
 343 }
 344
 345 void do_trap0(struct pt_regs *regs)
 346 {
 347         syscall_fn syscall;
 348
 349         switch (pt_cause(regs)) {
 350         case TRAP_SYSCALL:
 351                 /* System call is trap0 #1 */
 352
 353                 /* allow strace to catch syscall args  */
 354                 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE) &&
 355                         tracehook_report_syscall_entry(regs)))
 356                         return;  /*  return -ENOSYS somewhere?  */
 357
 358                 /* Interrupts should be re-enabled for syscall processing */
 359                 __vmsetie(VM_INT_ENABLE);
 360
 361                 /*
 362                  * System call number is in r6, arguments in r0..r5.
 363                  * Fortunately, no Linux syscall has more than 6 arguments,
 364                  * and Hexagon ABI passes first 6 arguments in registers.
 365                  * 64-bit arguments are passed in odd/even register pairs.
 366                  * Fortunately, we have no system calls that take more
 367                  * than three arguments with more than one 64-bit value.
 368                  * Should that change, we'd need to redesign to copy
 369                  * between user and kernel stacks.
 370                  */
 371                 regs->syscall_nr = regs->r06;
 372
 373                 /*
 374                  * GPR R0 carries the first parameter, and is also used
 375                  * to report the return value.  We need a backup of
 376                  * the user's value in case we need to do a late restart
 377                  * of the system call.
 378                  */
 379                 regs->restart_r0 = regs->r00;
 380
 381                 if ((unsigned long) regs->syscall_nr >= __NR_syscalls) {
 382                         regs->r00 = -1;
 383                 } else {
 384                         syscall = (syscall_fn)
 385                                   (sys_call_table[regs->syscall_nr]);
 386                         regs->r00 = syscall(regs->r00, regs->r01,
 387                                    regs->r02, regs->r03,
 388                                    regs->r04, regs->r05);
 389                 }
 390
 391                 /* allow strace to get the syscall return state  */
 392                 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE)))
 393                         tracehook_report_syscall_exit(regs, 0);
 394
 395                 break;
 396         case TRAP_DEBUG:
 397                 /* Trap0 0xdb is debug breakpoint */
 398                 if (user_mode(regs)) {
 399                         /*
 400                          * Some architecures add some per-thread state
 401                          * to distinguish between breakpoint traps and
 402                          * trace traps.  We may want to do that, and
 403                          * set the si_code value appropriately, or we
 404                          * may want to use a different trap0 flavor.
 405                          */
 406                         force_sig_fault(SIGTRAP, TRAP_BRKPT,
 407                                         (void __user *) pt_elr(regs));
 408                 } else {
 409 #ifdef CONFIG_KGDB
 410                         kgdb_handle_exception(pt_cause(regs), SIGTRAP,
 411                                               TRAP_BRKPT, regs);
 412 #endif
 413                 }
 414                 break;
 415         }
 416         /* Ignore other trap0 codes for now, especially 0 (Angel calls) */
 417 }
 418
 419 /*
 420  * Machine check exception handler
 421  */
 422 void do_machcheck(struct pt_regs *regs)
 423 {
 424         /* Halt and catch fire */
 425         __vmstop();
 426 }
 427
 428 /*
 429  * Treat this like the old 0xdb trap.
 430  */
 431
 432 void do_debug_exception(struct pt_regs *regs)
 433 {
 434         regs->hvmer.vmest &= ~HVM_VMEST_CAUSE_MSK;
 435         regs->hvmer.vmest |= (TRAP_DEBUG << HVM_VMEST_CAUSE_SFT);
 436         do_trap0(regs);
 437 }