arch/avr32/kernel/ptrace.c

   1 /*
   2  * Copyright (C) 2004-2006 Atmel Corporation
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  */
   8 #undef DEBUG
   9 #include <linux/kernel.h>
  10 #include <linux/sched.h>
  11 #include <linux/mm.h>
  12 #include <linux/ptrace.h>
  13 #include <linux/errno.h>
  14 #include <linux/user.h>
  15 #include <linux/security.h>
  16 #include <linux/unistd.h>
  17 #include <linux/notifier.h>
  18
  19 #include <asm/traps.h>
  20 #include <asm/uaccess.h>
  21 #include <asm/ocd.h>
  22 #include <asm/mmu_context.h>
  23 #include <linux/kdebug.h>
  24
  25 static struct pt_regs *get_user_regs(struct task_struct *tsk)
  26 {
  27         return (struct pt_regs *)((unsigned long)task_stack_page(tsk) +
  28                                   THREAD_SIZE - sizeof(struct pt_regs));
  29 }
  30
  31 static void ptrace_single_step(struct task_struct *tsk)
  32 {
  33         pr_debug("ptrace_single_step: pid=%u, SR=0x%08lx\n",
  34                  tsk->pid, tsk->thread.cpu_context.sr);
  35         if (!(tsk->thread.cpu_context.sr & SR_D)) {
  36                 /*
  37                  * Set a breakpoint at the current pc to force the
  38                  * process into debug mode.  The syscall/exception
  39                  * exit code will set a breakpoint at the return
  40                  * address when this flag is set.
  41                  */
  42                 pr_debug("ptrace_single_step: Setting TIF_BREAKPOINT\n");
  43                 set_tsk_thread_flag(tsk, TIF_BREAKPOINT);
  44         }
  45
  46         /* The monitor code will do the actual step for us */
  47         set_tsk_thread_flag(tsk, TIF_SINGLE_STEP);
  48 }
  49
  50 /*
  51  * Called by kernel/ptrace.c when detaching
  52  *
  53  * Make sure any single step bits, etc. are not set
  54  */
  55 void ptrace_disable(struct task_struct *child)
  56 {
  57         clear_tsk_thread_flag(child, TIF_SINGLE_STEP);
  58 }
  59
  60 /*
  61  * Handle hitting a breakpoint
  62  */
  63 static void ptrace_break(struct task_struct *tsk, struct pt_regs *regs)
  64 {
  65         siginfo_t info;
  66
  67         info.si_signo = SIGTRAP;
  68         info.si_errno = 0;
  69         info.si_code  = TRAP_BRKPT;
  70         info.si_addr  = (void __user *)instruction_pointer(regs);
  71
  72         pr_debug("ptrace_break: Sending SIGTRAP to PID %u (pc = 0x%p)\n",
  73                  tsk->pid, info.si_addr);
  74         force_sig_info(SIGTRAP, &info, tsk);
  75 }
  76
  77 /*
  78  * Read the word at offset "offset" into the task's "struct user". We
  79  * actually access the pt_regs struct stored on the kernel stack.
  80  */
  81 static int ptrace_read_user(struct task_struct *tsk, unsigned long offset,
  82                             unsigned long __user *data)
  83 {
  84         unsigned long *regs;
  85         unsigned long value;
  86
  87         pr_debug("ptrace_read_user(%p, %#lx, %p)\n",
  88                  tsk, offset, data);
  89
  90         if (offset & 3 || offset >= sizeof(struct user)) {
  91                 printk("ptrace_read_user: invalid offset 0x%08lx\n", offset);
  92                 return -EIO;
  93         }
  94
  95         regs = (unsigned long *)get_user_regs(tsk);
  96
  97         value = 0;
  98         if (offset < sizeof(struct pt_regs))
  99                 value = regs[offset / sizeof(regs[0])];
 100
 101         return put_user(value, data);
 102 }
 103
 104 /*
 105  * Write the word "value" to offset "offset" into the task's "struct
 106  * user". We actually access the pt_regs struct stored on the kernel
 107  * stack.
 108  */
 109 static int ptrace_write_user(struct task_struct *tsk, unsigned long offset,
 110                              unsigned long value)
 111 {
 112         unsigned long *regs;
 113
 114         if (offset & 3 || offset >= sizeof(struct user)) {
 115                 printk("ptrace_write_user: invalid offset 0x%08lx\n", offset);
 116                 return -EIO;
 117         }
 118
 119         if (offset >= sizeof(struct pt_regs))
 120                 return 0;
 121
 122         regs = (unsigned long *)get_user_regs(tsk);
 123         regs[offset / sizeof(regs[0])] = value;
 124
 125         return 0;
 126 }
 127
 128 static int ptrace_getregs(struct task_struct *tsk, void __user *uregs)
 129 {
 130         struct pt_regs *regs = get_user_regs(tsk);
 131
 132         return copy_to_user(uregs, regs, sizeof(*regs)) ? -EFAULT : 0;
 133 }
 134
 135 static int ptrace_setregs(struct task_struct *tsk, const void __user *uregs)
 136 {
 137         struct pt_regs newregs;
 138         int ret;
 139
 140         ret = -EFAULT;
 141         if (copy_from_user(&newregs, uregs, sizeof(newregs)) == 0) {
 142                 struct pt_regs *regs = get_user_regs(tsk);
 143
 144                 ret = -EINVAL;
 145                 if (valid_user_regs(&newregs)) {
 146                         *regs = newregs;
 147                         ret = 0;
 148                 }
 149         }
 150
 151         return ret;
 152 }
 153
 154 long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 155 {
 156         int ret;
 157
 158         pr_debug("arch_ptrace(%ld, %d, %#lx, %#lx)\n",
 159                  request, child->pid, addr, data);
 160
 161         pr_debug("ptrace: Enabling monitor mode...\n");
 162         __mtdr(DBGREG_DC, __mfdr(DBGREG_DC) | DC_MM | DC_DBE);
 163
 164         switch (request) {
 165         /* Read the word at location addr in the child process */
 166         case PTRACE_PEEKTEXT:
 167         case PTRACE_PEEKDATA:
 168                 ret = generic_ptrace_peekdata(child, addr, data);
 169                 break;
 170
 171         case PTRACE_PEEKUSR:
 172                 ret = ptrace_read_user(child, addr,
 173                                        (unsigned long __user *)data);
 174                 break;
 175
 176         /* Write the word in data at location addr */
 177         case PTRACE_POKETEXT:
 178         case PTRACE_POKEDATA:
 179                 ret = generic_ptrace_pokedata(child, addr, data);
 180                 break;
 181
 182         case PTRACE_POKEUSR:
 183                 ret = ptrace_write_user(child, addr, data);
 184                 break;
 185
 186         /* continue and stop at next (return from) syscall */
 187         case PTRACE_SYSCALL:
 188         /* restart after signal */
 189         case PTRACE_CONT:
 190                 ret = -EIO;
 191                 if (!valid_signal(data))
 192                         break;
 193                 if (request == PTRACE_SYSCALL)
 194                         set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 195                 else
 196                         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 197                 child->exit_code = data;
 198                 /* XXX: Are we sure no breakpoints are active here? */
 199                 wake_up_process(child);
 200                 ret = 0;
 201                 break;
 202
 203         /*
 204          * Make the child exit. Best I can do is send it a
 205          * SIGKILL. Perhaps it should be put in the status that it
 206          * wants to exit.
 207          */
 208         case PTRACE_KILL:
 209                 ret = 0;
 210                 if (child->exit_state == EXIT_ZOMBIE)
 211                         break;
 212                 child->exit_code = SIGKILL;
 213                 wake_up_process(child);
 214                 break;
 215
 216         /*
 217          * execute single instruction.
 218          */
 219         case PTRACE_SINGLESTEP:
 220                 ret = -EIO;
 221                 if (!valid_signal(data))
 222                         break;
 223                 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 224                 ptrace_single_step(child);
 225                 child->exit_code = data;
 226                 wake_up_process(child);
 227                 ret = 0;
 228                 break;
 229
 230         /* Detach a process that was attached */
 231         case PTRACE_DETACH:
 232                 ret = ptrace_detach(child, data);
 233                 break;
 234
 235         case PTRACE_GETREGS:
 236                 ret = ptrace_getregs(child, (void __user *)data);
 237                 break;
 238
 239         case PTRACE_SETREGS:
 240                 ret = ptrace_setregs(child, (const void __user *)data);
 241                 break;
 242
 243         default:
 244                 ret = ptrace_request(child, request, addr, data);
 245                 break;
 246         }
 247
 248         pr_debug("sys_ptrace returning %d (DC = 0x%08lx)\n", ret, __mfdr(DBGREG_DC));
 249         return ret;
 250 }
 251
 252 asmlinkage void syscall_trace(void)
 253 {
 254         pr_debug("syscall_trace called\n");
 255         if (!test_thread_flag(TIF_SYSCALL_TRACE))
 256                 return;
 257         if (!(current->ptrace & PT_PTRACED))
 258                 return;
 259
 260         pr_debug("syscall_trace: notifying parent\n");
 261         /* The 0x80 provides a way for the tracing parent to
 262          * distinguish between a syscall stop and SIGTRAP delivery */
 263         ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
 264                                  ? 0x80 : 0));
 265
 266         /*
 267          * this isn't the same as continuing with a signal, but it
 268          * will do for normal use.  strace only continues with a
 269          * signal if the stopping signal is not SIGTRAP.  -brl
 270          */
 271         if (current->exit_code) {
 272                 pr_debug("syscall_trace: sending signal %d to PID %u\n",
 273                          current->exit_code, current->pid);
 274                 send_sig(current->exit_code, current, 1);
 275                 current->exit_code = 0;
 276         }
 277 }
 278
 279 asmlinkage void do_debug_priv(struct pt_regs *regs)
 280 {
 281         unsigned long dc, ds;
 282         unsigned long die_val;
 283
 284         ds = __mfdr(DBGREG_DS);
 285
 286         pr_debug("do_debug_priv: pc = %08lx, ds = %08lx\n", regs->pc, ds);
 287
 288         if (ds & DS_SSS)
 289                 die_val = DIE_SSTEP;
 290         else
 291                 die_val = DIE_BREAKPOINT;
 292
 293         if (notify_die(die_val, "ptrace", regs, 0, 0, SIGTRAP) == NOTIFY_STOP)
 294                 return;
 295
 296         if (likely(ds & DS_SSS)) {
 297                 extern void itlb_miss(void);
 298                 extern void tlb_miss_common(void);
 299                 struct thread_info *ti;
 300
 301                 dc = __mfdr(DBGREG_DC);
 302                 dc &= ~DC_SS;
 303                 __mtdr(DBGREG_DC, dc);
 304
 305                 ti = current_thread_info();
 306                 set_ti_thread_flag(ti, TIF_BREAKPOINT);
 307
 308                 /* The TLB miss handlers don't check thread flags */
 309                 if ((regs->pc >= (unsigned long)&itlb_miss)
 310                     && (regs->pc <= (unsigned long)&tlb_miss_common)) {
 311                         __mtdr(DBGREG_BWA2A, sysreg_read(RAR_EX));
 312                         __mtdr(DBGREG_BWC2A, 0x40000001 | (get_asid() << 1));
 313                 }
 314
 315                 /*
 316                  * If we're running in supervisor mode, the breakpoint
 317                  * will take us where we want directly, no need to
 318                  * single step.
 319                  */
 320                 if ((regs->sr & MODE_MASK) != MODE_SUPERVISOR)
 321                         set_ti_thread_flag(ti, TIF_SINGLE_STEP);
 322         } else {
 323                 panic("Unable to handle debug trap at pc = %08lx\n",
 324                       regs->pc);
 325         }
 326 }
 327
 328 /*
 329  * Handle breakpoints, single steps and other debuggy things. To keep
 330  * things simple initially, we run with interrupts and exceptions
 331  * disabled all the time.
 332  */
 333 asmlinkage void do_debug(struct pt_regs *regs)
 334 {
 335         unsigned long dc, ds;
 336
 337         ds = __mfdr(DBGREG_DS);
 338         pr_debug("do_debug: pc = %08lx, ds = %08lx\n", regs->pc, ds);
 339
 340         if (test_thread_flag(TIF_BREAKPOINT)) {
 341                 pr_debug("TIF_BREAKPOINT set\n");
 342                 /* We're taking care of it */
 343                 clear_thread_flag(TIF_BREAKPOINT);
 344                 __mtdr(DBGREG_BWC2A, 0);
 345         }
 346
 347         if (test_thread_flag(TIF_SINGLE_STEP)) {
 348                 pr_debug("TIF_SINGLE_STEP set, ds = 0x%08lx\n", ds);
 349                 if (ds & DS_SSS) {
 350                         dc = __mfdr(DBGREG_DC);
 351                         dc &= ~DC_SS;
 352                         __mtdr(DBGREG_DC, dc);
 353
 354                         clear_thread_flag(TIF_SINGLE_STEP);
 355                         ptrace_break(current, regs);
 356                 }
 357         } else {
 358                 /* regular breakpoint */
 359                 ptrace_break(current, regs);
 360         }
 361 }