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 = access_process_vm(child, addr, &data, sizeof(data), 1);
 180                 if (ret == sizeof(data))
 181                         ret = 0;
 182                 else
 183                         ret = -EIO;
 184                 break;
 185
 186         case PTRACE_POKEUSR:
 187                 ret = ptrace_write_user(child, addr, data);
 188                 break;
 189
 190         /* continue and stop at next (return from) syscall */
 191         case PTRACE_SYSCALL:
 192         /* restart after signal */
 193         case PTRACE_CONT:
 194                 ret = -EIO;
 195                 if (!valid_signal(data))
 196                         break;
 197                 if (request == PTRACE_SYSCALL)
 198                         set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 199                 else
 200                         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 201                 child->exit_code = data;
 202                 /* XXX: Are we sure no breakpoints are active here? */
 203                 wake_up_process(child);
 204                 ret = 0;
 205                 break;
 206
 207         /*
 208          * Make the child exit. Best I can do is send it a
 209          * SIGKILL. Perhaps it should be put in the status that it
 210          * wants to exit.
 211          */
 212         case PTRACE_KILL:
 213                 ret = 0;
 214                 if (child->exit_state == EXIT_ZOMBIE)
 215                         break;
 216                 child->exit_code = SIGKILL;
 217                 wake_up_process(child);
 218                 break;
 219
 220         /*
 221          * execute single instruction.
 222          */
 223         case PTRACE_SINGLESTEP:
 224                 ret = -EIO;
 225                 if (!valid_signal(data))
 226                         break;
 227                 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 228                 ptrace_single_step(child);
 229                 child->exit_code = data;
 230                 wake_up_process(child);
 231                 ret = 0;
 232                 break;
 233
 234         /* Detach a process that was attached */
 235         case PTRACE_DETACH:
 236                 ret = ptrace_detach(child, data);
 237                 break;
 238
 239         case PTRACE_GETREGS:
 240                 ret = ptrace_getregs(child, (void __user *)data);
 241                 break;
 242
 243         case PTRACE_SETREGS:
 244                 ret = ptrace_setregs(child, (const void __user *)data);
 245                 break;
 246
 247         default:
 248                 ret = ptrace_request(child, request, addr, data);
 249                 break;
 250         }
 251
 252         pr_debug("sys_ptrace returning %d (DC = 0x%08lx)\n", ret, __mfdr(DBGREG_DC));
 253         return ret;
 254 }
 255
 256 asmlinkage void syscall_trace(void)
 257 {
 258         pr_debug("syscall_trace called\n");
 259         if (!test_thread_flag(TIF_SYSCALL_TRACE))
 260                 return;
 261         if (!(current->ptrace & PT_PTRACED))
 262                 return;
 263
 264         pr_debug("syscall_trace: notifying parent\n");
 265         /* The 0x80 provides a way for the tracing parent to
 266          * distinguish between a syscall stop and SIGTRAP delivery */
 267         ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
 268                                  ? 0x80 : 0));
 269
 270         /*
 271          * this isn't the same as continuing with a signal, but it
 272          * will do for normal use.  strace only continues with a
 273          * signal if the stopping signal is not SIGTRAP.  -brl
 274          */
 275         if (current->exit_code) {
 276                 pr_debug("syscall_trace: sending signal %d to PID %u\n",
 277                          current->exit_code, current->pid);
 278                 send_sig(current->exit_code, current, 1);
 279                 current->exit_code = 0;
 280         }
 281 }
 282
 283 asmlinkage void do_debug_priv(struct pt_regs *regs)
 284 {
 285         unsigned long dc, ds;
 286         unsigned long die_val;
 287
 288         ds = __mfdr(DBGREG_DS);
 289
 290         pr_debug("do_debug_priv: pc = %08lx, ds = %08lx\n", regs->pc, ds);
 291
 292         if (ds & DS_SSS)
 293                 die_val = DIE_SSTEP;
 294         else
 295                 die_val = DIE_BREAKPOINT;
 296
 297         if (notify_die(die_val, "ptrace", regs, 0, 0, SIGTRAP) == NOTIFY_STOP)
 298                 return;
 299
 300         if (likely(ds & DS_SSS)) {
 301                 extern void itlb_miss(void);
 302                 extern void tlb_miss_common(void);
 303                 struct thread_info *ti;
 304
 305                 dc = __mfdr(DBGREG_DC);
 306                 dc &= ~DC_SS;
 307                 __mtdr(DBGREG_DC, dc);
 308
 309                 ti = current_thread_info();
 310                 set_ti_thread_flag(ti, TIF_BREAKPOINT);
 311
 312                 /* The TLB miss handlers don't check thread flags */
 313                 if ((regs->pc >= (unsigned long)&itlb_miss)
 314                     && (regs->pc <= (unsigned long)&tlb_miss_common)) {
 315                         __mtdr(DBGREG_BWA2A, sysreg_read(RAR_EX));
 316                         __mtdr(DBGREG_BWC2A, 0x40000001 | (get_asid() << 1));
 317                 }
 318
 319                 /*
 320                  * If we're running in supervisor mode, the breakpoint
 321                  * will take us where we want directly, no need to
 322                  * single step.
 323                  */
 324                 if ((regs->sr & MODE_MASK) != MODE_SUPERVISOR)
 325                         set_ti_thread_flag(ti, TIF_SINGLE_STEP);
 326         } else {
 327                 panic("Unable to handle debug trap at pc = %08lx\n",
 328                       regs->pc);
 329         }
 330 }
 331
 332 /*
 333  * Handle breakpoints, single steps and other debuggy things. To keep
 334  * things simple initially, we run with interrupts and exceptions
 335  * disabled all the time.
 336  */
 337 asmlinkage void do_debug(struct pt_regs *regs)
 338 {
 339         unsigned long dc, ds;
 340
 341         ds = __mfdr(DBGREG_DS);
 342         pr_debug("do_debug: pc = %08lx, ds = %08lx\n", regs->pc, ds);
 343
 344         if (test_thread_flag(TIF_BREAKPOINT)) {
 345                 pr_debug("TIF_BREAKPOINT set\n");
 346                 /* We're taking care of it */
 347                 clear_thread_flag(TIF_BREAKPOINT);
 348                 __mtdr(DBGREG_BWC2A, 0);
 349         }
 350
 351         if (test_thread_flag(TIF_SINGLE_STEP)) {
 352                 pr_debug("TIF_SINGLE_STEP set, ds = 0x%08lx\n", ds);
 353                 if (ds & DS_SSS) {
 354                         dc = __mfdr(DBGREG_DC);
 355                         dc &= ~DC_SS;
 356                         __mtdr(DBGREG_DC, dc);
 357
 358                         clear_thread_flag(TIF_SINGLE_STEP);
 359                         ptrace_break(current, regs);
 360                 }
 361         } else {
 362                 /* regular breakpoint */
 363                 ptrace_break(current, regs);
 364         }
 365 }