arch/sh/kernel/ptrace_32.c

   1 /*
   2  * SuperH process tracing
   3  *
   4  * Copyright (C) 1999, 2000  Kaz Kojima & Niibe Yutaka
   5  * Copyright (C) 2002 - 2009  Paul Mundt
   6  *
   7  * Audit support by Yuichi Nakamura <ynakam@hitachisoft.jp>
   8  *
   9  * This file is subject to the terms and conditions of the GNU General Public
  10  * License.  See the file "COPYING" in the main directory of this archive
  11  * for more details.
  12  */
  13 #include <linux/kernel.h>
  14 #include <linux/sched.h>
  15 #include <linux/mm.h>
  16 #include <linux/smp.h>
  17 #include <linux/errno.h>
  18 #include <linux/ptrace.h>
  19 #include <linux/user.h>
  20 #include <linux/security.h>
  21 #include <linux/signal.h>
  22 #include <linux/io.h>
  23 #include <linux/audit.h>
  24 #include <linux/seccomp.h>
  25 #include <linux/tracehook.h>
  26 #include <linux/elf.h>
  27 #include <linux/regset.h>
  28 #include <linux/hw_breakpoint.h>
  29 #include <asm/uaccess.h>
  30 #include <asm/pgtable.h>
  31 #include <asm/processor.h>
  32 #include <asm/mmu_context.h>
  33 #include <asm/syscalls.h>
  34 #include <asm/fpu.h>
  35
  36 #define CREATE_TRACE_POINTS
  37 #include <trace/events/syscalls.h>
  38
  39 /*
  40  * This routine will get a word off of the process kernel stack.
  41  */
  42 static inline int get_stack_long(struct task_struct *task, int offset)
  43 {
  44         unsigned char *stack;
  45
  46         stack = (unsigned char *)task_pt_regs(task);
  47         stack += offset;
  48         return (*((int *)stack));
  49 }
  50
  51 /*
  52  * This routine will put a word on the process kernel stack.
  53  */
  54 static inline int put_stack_long(struct task_struct *task, int offset,
  55                                  unsigned long data)
  56 {
  57         unsigned char *stack;
  58
  59         stack = (unsigned char *)task_pt_regs(task);
  60         stack += offset;
  61         *(unsigned long *) stack = data;
  62         return 0;
  63 }
  64
  65 void ptrace_triggered(struct perf_event *bp,
  66                       struct perf_sample_data *data, struct pt_regs *regs)
  67 {
  68         struct perf_event_attr attr;
  69
  70         /*
  71          * Disable the breakpoint request here since ptrace has defined a
  72          * one-shot behaviour for breakpoint exceptions.
  73          */
  74         attr = bp->attr;
  75         attr.disabled = true;
  76         modify_user_hw_breakpoint(bp, &attr);
  77 }
  78
  79 static int set_single_step(struct task_struct *tsk, unsigned long addr)
  80 {
  81         struct thread_struct *thread = &tsk->thread;
  82         struct perf_event *bp;
  83         struct perf_event_attr attr;
  84
  85         bp = thread->ptrace_bps[0];
  86         if (!bp) {
  87                 ptrace_breakpoint_init(&attr);
  88
  89                 attr.bp_addr = addr;
  90                 attr.bp_len = HW_BREAKPOINT_LEN_2;
  91                 attr.bp_type = HW_BREAKPOINT_R;
  92
  93                 bp = register_user_hw_breakpoint(&attr, ptrace_triggered,
  94                                                  NULL, tsk);
  95                 if (IS_ERR(bp))
  96                         return PTR_ERR(bp);
  97
  98                 thread->ptrace_bps[0] = bp;
  99         } else {
 100                 int err;
 101
 102                 attr = bp->attr;
 103                 attr.bp_addr = addr;
 104                 /* reenable breakpoint */
 105                 attr.disabled = false;
 106                 err = modify_user_hw_breakpoint(bp, &attr);
 107                 if (unlikely(err))
 108                         return err;
 109         }
 110
 111         return 0;
 112 }
 113
 114 void user_enable_single_step(struct task_struct *child)
 115 {
 116         unsigned long pc = get_stack_long(child, offsetof(struct pt_regs, pc));
 117
 118         set_tsk_thread_flag(child, TIF_SINGLESTEP);
 119
 120         set_single_step(child, pc);
 121 }
 122
 123 void user_disable_single_step(struct task_struct *child)
 124 {
 125         clear_tsk_thread_flag(child, TIF_SINGLESTEP);
 126 }
 127
 128 /*
 129  * Called by kernel/ptrace.c when detaching..
 130  *
 131  * Make sure single step bits etc are not set.
 132  */
 133 void ptrace_disable(struct task_struct *child)
 134 {
 135         user_disable_single_step(child);
 136 }
 137
 138 static int genregs_get(struct task_struct *target,
 139                        const struct user_regset *regset,
 140                        unsigned int pos, unsigned int count,
 141                        void *kbuf, void __user *ubuf)
 142 {
 143         const struct pt_regs *regs = task_pt_regs(target);
 144         int ret;
 145
 146         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
 147                                   regs->regs,
 148                                   0, 16 * sizeof(unsigned long));
 149         if (!ret)
 150                 /* PC, PR, SR, GBR, MACH, MACL, TRA */
 151                 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
 152                                           &regs->pc,
 153                                           offsetof(struct pt_regs, pc),
 154                                           sizeof(struct pt_regs));
 155         if (!ret)
 156                 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
 157                                                sizeof(struct pt_regs), -1);
 158
 159         return ret;
 160 }
 161
 162 static int genregs_set(struct task_struct *target,
 163                        const struct user_regset *regset,
 164                        unsigned int pos, unsigned int count,
 165                        const void *kbuf, const void __user *ubuf)
 166 {
 167         struct pt_regs *regs = task_pt_regs(target);
 168         int ret;
 169
 170         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 171                                  regs->regs,
 172                                  0, 16 * sizeof(unsigned long));
 173         if (!ret && count > 0)
 174                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 175                                          &regs->pc,
 176                                          offsetof(struct pt_regs, pc),
 177                                          sizeof(struct pt_regs));
 178         if (!ret)
 179                 ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
 180                                                 sizeof(struct pt_regs), -1);
 181
 182         return ret;
 183 }
 184
 185 #ifdef CONFIG_SH_FPU
 186 int fpregs_get(struct task_struct *target,
 187                const struct user_regset *regset,
 188                unsigned int pos, unsigned int count,
 189                void *kbuf, void __user *ubuf)
 190 {
 191         int ret;
 192
 193         ret = init_fpu(target);
 194         if (ret)
 195                 return ret;
 196
 197         if ((boot_cpu_data.flags & CPU_HAS_FPU))
 198                 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
 199                                            &target->thread.xstate->hardfpu, 0, -1);
 200
 201         return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
 202                                    &target->thread.xstate->softfpu, 0, -1);
 203 }
 204
 205 static int fpregs_set(struct task_struct *target,
 206                        const struct user_regset *regset,
 207                        unsigned int pos, unsigned int count,
 208                        const void *kbuf, const void __user *ubuf)
 209 {
 210         int ret;
 211
 212         ret = init_fpu(target);
 213         if (ret)
 214                 return ret;
 215
 216         set_stopped_child_used_math(target);
 217
 218         if ((boot_cpu_data.flags & CPU_HAS_FPU))
 219                 return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 220                                           &target->thread.xstate->hardfpu, 0, -1);
 221
 222         return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 223                                   &target->thread.xstate->softfpu, 0, -1);
 224 }
 225
 226 static int fpregs_active(struct task_struct *target,
 227                          const struct user_regset *regset)
 228 {
 229         return tsk_used_math(target) ? regset->n : 0;
 230 }
 231 #endif
 232
 233 #ifdef CONFIG_SH_DSP
 234 static int dspregs_get(struct task_struct *target,
 235                        const struct user_regset *regset,
 236                        unsigned int pos, unsigned int count,
 237                        void *kbuf, void __user *ubuf)
 238 {
 239         const struct pt_dspregs *regs =
 240                 (struct pt_dspregs *)&target->thread.dsp_status.dsp_regs;
 241         int ret;
 242
 243         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs,
 244                                   0, sizeof(struct pt_dspregs));
 245         if (!ret)
 246                 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
 247                                                sizeof(struct pt_dspregs), -1);
 248
 249         return ret;
 250 }
 251
 252 static int dspregs_set(struct task_struct *target,
 253                        const struct user_regset *regset,
 254                        unsigned int pos, unsigned int count,
 255                        const void *kbuf, const void __user *ubuf)
 256 {
 257         struct pt_dspregs *regs =
 258                 (struct pt_dspregs *)&target->thread.dsp_status.dsp_regs;
 259         int ret;
 260
 261         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, regs,
 262                                  0, sizeof(struct pt_dspregs));
 263         if (!ret)
 264                 ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
 265                                                 sizeof(struct pt_dspregs), -1);
 266
 267         return ret;
 268 }
 269
 270 static int dspregs_active(struct task_struct *target,
 271                           const struct user_regset *regset)
 272 {
 273         struct pt_regs *regs = task_pt_regs(target);
 274
 275         return regs->sr & SR_DSP ? regset->n : 0;
 276 }
 277 #endif
 278
 279 const struct pt_regs_offset regoffset_table[] = {
 280         REGS_OFFSET_NAME(0),
 281         REGS_OFFSET_NAME(1),
 282         REGS_OFFSET_NAME(2),
 283         REGS_OFFSET_NAME(3),
 284         REGS_OFFSET_NAME(4),
 285         REGS_OFFSET_NAME(5),
 286         REGS_OFFSET_NAME(6),
 287         REGS_OFFSET_NAME(7),
 288         REGS_OFFSET_NAME(8),
 289         REGS_OFFSET_NAME(9),
 290         REGS_OFFSET_NAME(10),
 291         REGS_OFFSET_NAME(11),
 292         REGS_OFFSET_NAME(12),
 293         REGS_OFFSET_NAME(13),
 294         REGS_OFFSET_NAME(14),
 295         REGS_OFFSET_NAME(15),
 296         REG_OFFSET_NAME(pc),
 297         REG_OFFSET_NAME(pr),
 298         REG_OFFSET_NAME(sr),
 299         REG_OFFSET_NAME(gbr),
 300         REG_OFFSET_NAME(mach),
 301         REG_OFFSET_NAME(macl),
 302         REG_OFFSET_NAME(tra),
 303         REG_OFFSET_END,
 304 };
 305
 306 /*
 307  * These are our native regset flavours.
 308  */
 309 enum sh_regset {
 310         REGSET_GENERAL,
 311 #ifdef CONFIG_SH_FPU
 312         REGSET_FPU,
 313 #endif
 314 #ifdef CONFIG_SH_DSP
 315         REGSET_DSP,
 316 #endif
 317 };
 318
 319 static const struct user_regset sh_regsets[] = {
 320         /*
 321          * Format is:
 322          *      R0 --> R15
 323          *      PC, PR, SR, GBR, MACH, MACL, TRA
 324          */
 325         [REGSET_GENERAL] = {
 326                 .core_note_type = NT_PRSTATUS,
 327                 .n              = ELF_NGREG,
 328                 .size           = sizeof(long),
 329                 .align          = sizeof(long),
 330                 .get            = genregs_get,
 331                 .set            = genregs_set,
 332         },
 333
 334 #ifdef CONFIG_SH_FPU
 335         [REGSET_FPU] = {
 336                 .core_note_type = NT_PRFPREG,
 337                 .n              = sizeof(struct user_fpu_struct) / sizeof(long),
 338                 .size           = sizeof(long),
 339                 .align          = sizeof(long),
 340                 .get            = fpregs_get,
 341                 .set            = fpregs_set,
 342                 .active         = fpregs_active,
 343         },
 344 #endif
 345
 346 #ifdef CONFIG_SH_DSP
 347         [REGSET_DSP] = {
 348                 .n              = sizeof(struct pt_dspregs) / sizeof(long),
 349                 .size           = sizeof(long),
 350                 .align          = sizeof(long),
 351                 .get            = dspregs_get,
 352                 .set            = dspregs_set,
 353                 .active         = dspregs_active,
 354         },
 355 #endif
 356 };
 357
 358 static const struct user_regset_view user_sh_native_view = {
 359         .name           = "sh",
 360         .e_machine      = EM_SH,
 361         .regsets        = sh_regsets,
 362         .n              = ARRAY_SIZE(sh_regsets),
 363 };
 364
 365 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
 366 {
 367         return &user_sh_native_view;
 368 }
 369
 370 long arch_ptrace(struct task_struct *child, long request,
 371                  unsigned long addr, unsigned long data)
 372 {
 373         unsigned long __user *datap = (unsigned long __user *)data;
 374         int ret;
 375
 376         switch (request) {
 377         /* read the word at location addr in the USER area. */
 378         case PTRACE_PEEKUSR: {
 379                 unsigned long tmp;
 380
 381                 ret = -EIO;
 382                 if ((addr & 3) || addr < 0 ||
 383                     addr > sizeof(struct user) - 3)
 384                         break;
 385
 386                 if (addr < sizeof(struct pt_regs))
 387                         tmp = get_stack_long(child, addr);
 388                 else if (addr >= offsetof(struct user, fpu) &&
 389                          addr < offsetof(struct user, u_fpvalid)) {
 390                         if (!tsk_used_math(child)) {
 391                                 if (addr == offsetof(struct user, fpu.fpscr))
 392                                         tmp = FPSCR_INIT;
 393                                 else
 394                                         tmp = 0;
 395                         } else {
 396                                 unsigned long index;
 397                                 ret = init_fpu(child);
 398                                 if (ret)
 399                                         break;
 400                                 index = addr - offsetof(struct user, fpu);
 401                                 tmp = ((unsigned long *)child->thread.xstate)
 402                                         [index >> 2];
 403                         }
 404                 } else if (addr == offsetof(struct user, u_fpvalid))
 405                         tmp = !!tsk_used_math(child);
 406                 else if (addr == PT_TEXT_ADDR)
 407                         tmp = child->mm->start_code;
 408                 else if (addr == PT_DATA_ADDR)
 409                         tmp = child->mm->start_data;
 410                 else if (addr == PT_TEXT_END_ADDR)
 411                         tmp = child->mm->end_code;
 412                 else if (addr == PT_TEXT_LEN)
 413                         tmp = child->mm->end_code - child->mm->start_code;
 414                 else
 415                         tmp = 0;
 416                 ret = put_user(tmp, datap);
 417                 break;
 418         }
 419
 420         case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
 421                 ret = -EIO;
 422                 if ((addr & 3) || addr < 0 ||
 423                     addr > sizeof(struct user) - 3)
 424                         break;
 425
 426                 if (addr < sizeof(struct pt_regs))
 427                         ret = put_stack_long(child, addr, data);
 428                 else if (addr >= offsetof(struct user, fpu) &&
 429                          addr < offsetof(struct user, u_fpvalid)) {
 430                         unsigned long index;
 431                         ret = init_fpu(child);
 432                         if (ret)
 433                                 break;
 434                         index = addr - offsetof(struct user, fpu);
 435                         set_stopped_child_used_math(child);
 436                         ((unsigned long *)child->thread.xstate)
 437                                 [index >> 2] = data;
 438                         ret = 0;
 439                 } else if (addr == offsetof(struct user, u_fpvalid)) {
 440                         conditional_stopped_child_used_math(data, child);
 441                         ret = 0;
 442                 }
 443                 break;
 444
 445         case PTRACE_GETREGS:
 446                 return copy_regset_to_user(child, &user_sh_native_view,
 447                                            REGSET_GENERAL,
 448                                            0, sizeof(struct pt_regs),
 449                                            datap);
 450         case PTRACE_SETREGS:
 451                 return copy_regset_from_user(child, &user_sh_native_view,
 452                                              REGSET_GENERAL,
 453                                              0, sizeof(struct pt_regs),
 454                                              datap);
 455 #ifdef CONFIG_SH_FPU
 456         case PTRACE_GETFPREGS:
 457                 return copy_regset_to_user(child, &user_sh_native_view,
 458                                            REGSET_FPU,
 459                                            0, sizeof(struct user_fpu_struct),
 460                                            datap);
 461         case PTRACE_SETFPREGS:
 462                 return copy_regset_from_user(child, &user_sh_native_view,
 463                                              REGSET_FPU,
 464                                              0, sizeof(struct user_fpu_struct),
 465                                              datap);
 466 #endif
 467 #ifdef CONFIG_SH_DSP
 468         case PTRACE_GETDSPREGS:
 469                 return copy_regset_to_user(child, &user_sh_native_view,
 470                                            REGSET_DSP,
 471                                            0, sizeof(struct pt_dspregs),
 472                                            datap);
 473         case PTRACE_SETDSPREGS:
 474                 return copy_regset_from_user(child, &user_sh_native_view,
 475                                              REGSET_DSP,
 476                                              0, sizeof(struct pt_dspregs),
 477                                              datap);
 478 #endif
 479         default:
 480                 ret = ptrace_request(child, request, addr, data);
 481                 break;
 482         }
 483
 484         return ret;
 485 }
 486
 487 static inline int audit_arch(void)
 488 {
 489         int arch = EM_SH;
 490
 491 #ifdef CONFIG_CPU_LITTLE_ENDIAN
 492         arch |= __AUDIT_ARCH_LE;
 493 #endif
 494
 495         return arch;
 496 }
 497
 498 asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
 499 {
 500         long ret = 0;
 501
 502         secure_computing_strict(regs->regs[0]);
 503
 504         if (test_thread_flag(TIF_SYSCALL_TRACE) &&
 505             tracehook_report_syscall_entry(regs))
 506                 /*
 507                  * Tracing decided this syscall should not happen.
 508                  * We'll return a bogus call number to get an ENOSYS
 509                  * error, but leave the original number in regs->regs[0].
 510                  */
 511                 ret = -1L;
 512
 513         if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
 514                 trace_sys_enter(regs, regs->regs[0]);
 515
 516         audit_syscall_entry(audit_arch(), regs->regs[3],
 517                             regs->regs[4], regs->regs[5],
 518                             regs->regs[6], regs->regs[7]);
 519
 520         return ret ?: regs->regs[0];
 521 }
 522
 523 asmlinkage void do_syscall_trace_leave(struct pt_regs *regs)
 524 {
 525         int step;
 526
 527         audit_syscall_exit(regs);
 528
 529         if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
 530                 trace_sys_exit(regs, regs->regs[0]);
 531
 532         step = test_thread_flag(TIF_SINGLESTEP);
 533         if (step || test_thread_flag(TIF_SYSCALL_TRACE))
 534                 tracehook_report_syscall_exit(regs, step);
 535 }