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         case PTRACE_GETREGS:
 231                 ret = ptrace_getregs(child, (void __user *)data);
 232                 break;
 233
 234         case PTRACE_SETREGS:
 235                 ret = ptrace_setregs(child, (const void __user *)data);
 236                 break;
 237
 238         default:
 239                 ret = ptrace_request(child, request, addr, data);
 240                 break;
 241         }
 242
 243         pr_debug("sys_ptrace returning %d (DC = 0x%08lx)\n", ret, __mfdr(DBGREG_DC));
 244         return ret;
 245 }
 246
 247 asmlinkage void syscall_trace(void)
 248 {
 249         pr_debug("syscall_trace called\n");
 250         if (!test_thread_flag(TIF_SYSCALL_TRACE))
 251                 return;
 252         if (!(current->ptrace & PT_PTRACED))
 253                 return;
 254
 255         pr_debug("syscall_trace: notifying parent\n");
 256         /* The 0x80 provides a way for the tracing parent to
 257          * distinguish between a syscall stop and SIGTRAP delivery */
 258         ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
 259                                  ? 0x80 : 0));
 260
 261         /*
 262          * this isn't the same as continuing with a signal, but it
 263          * will do for normal use.  strace only continues with a
 264          * signal if the stopping signal is not SIGTRAP.  -brl
 265          */
 266         if (current->exit_code) {
 267                 pr_debug("syscall_trace: sending signal %d to PID %u\n",
 268                          current->exit_code, current->pid);
 269                 send_sig(current->exit_code, current, 1);
 270                 current->exit_code = 0;
 271         }
 272 }
 273
 274 asmlinkage void do_debug_priv(struct pt_regs *regs)
 275 {
 276         unsigned long dc, ds;
 277         unsigned long die_val;
 278
 279         ds = __mfdr(DBGREG_DS);
 280
 281         pr_debug("do_debug_priv: pc = %08lx, ds = %08lx\n", regs->pc, ds);
 282
 283         if (ds & DS_SSS)
 284                 die_val = DIE_SSTEP;
 285         else
 286                 die_val = DIE_BREAKPOINT;
 287
 288         if (notify_die(die_val, "ptrace", regs, 0, 0, SIGTRAP) == NOTIFY_STOP)
 289                 return;
 290
 291         if (likely(ds & DS_SSS)) {
 292                 extern void itlb_miss(void);
 293                 extern void tlb_miss_common(void);
 294                 struct thread_info *ti;
 295
 296                 dc = __mfdr(DBGREG_DC);
 297                 dc &= ~DC_SS;
 298                 __mtdr(DBGREG_DC, dc);
 299
 300                 ti = current_thread_info();
 301                 set_ti_thread_flag(ti, TIF_BREAKPOINT);
 302
 303                 /* The TLB miss handlers don't check thread flags */
 304                 if ((regs->pc >= (unsigned long)&itlb_miss)
 305                     && (regs->pc <= (unsigned long)&tlb_miss_common)) {
 306                         __mtdr(DBGREG_BWA2A, sysreg_read(RAR_EX));
 307                         __mtdr(DBGREG_BWC2A, 0x40000001 | (get_asid() << 1));
 308                 }
 309
 310                 /*
 311                  * If we're running in supervisor mode, the breakpoint
 312                  * will take us where we want directly, no need to
 313                  * single step.
 314                  */
 315                 if ((regs->sr & MODE_MASK) != MODE_SUPERVISOR)
 316                         set_ti_thread_flag(ti, TIF_SINGLE_STEP);
 317         } else {
 318                 panic("Unable to handle debug trap at pc = %08lx\n",
 319                       regs->pc);
 320         }
 321 }
 322
 323 /*
 324  * Handle breakpoints, single steps and other debuggy things. To keep
 325  * things simple initially, we run with interrupts and exceptions
 326  * disabled all the time.
 327  */
 328 asmlinkage void do_debug(struct pt_regs *regs)
 329 {
 330         unsigned long dc, ds;
 331
 332         ds = __mfdr(DBGREG_DS);
 333         pr_debug("do_debug: pc = %08lx, ds = %08lx\n", regs->pc, ds);
 334
 335         if (test_thread_flag(TIF_BREAKPOINT)) {
 336                 pr_debug("TIF_BREAKPOINT set\n");
 337                 /* We're taking care of it */
 338                 clear_thread_flag(TIF_BREAKPOINT);
 339                 __mtdr(DBGREG_BWC2A, 0);
 340         }
 341
 342         if (test_thread_flag(TIF_SINGLE_STEP)) {
 343                 pr_debug("TIF_SINGLE_STEP set, ds = 0x%08lx\n", ds);
 344                 if (ds & DS_SSS) {
 345                         dc = __mfdr(DBGREG_DC);
 346                         dc &= ~DC_SS;
 347                         __mtdr(DBGREG_DC, dc);
 348
 349                         clear_thread_flag(TIF_SINGLE_STEP);
 350                         ptrace_break(current, regs);
 351                 }
 352         } else {
 353                 /* regular breakpoint */
 354                 ptrace_break(current, regs);
 355         }
 356 }