arch/um/kernel/ptrace.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
   4  */
   5
   6 #include <linux/audit.h>
   7 #include <linux/ptrace.h>
   8 #include <linux/sched.h>
   9 #include <linux/uaccess.h>
  10 #include <asm/ptrace-abi.h>
  11
  12 void user_enable_single_step(struct task_struct *child)
  13 {
  14         set_tsk_thread_flag(child, TIF_SINGLESTEP);
  15         child->thread.singlestep_syscall = 0;
  16
  17 #ifdef SUBARCH_SET_SINGLESTEPPING
  18         SUBARCH_SET_SINGLESTEPPING(child, 1);
  19 #endif
  20 }
  21
  22 void user_disable_single_step(struct task_struct *child)
  23 {
  24         clear_tsk_thread_flag(child, TIF_SINGLESTEP);
  25         child->thread.singlestep_syscall = 0;
  26
  27 #ifdef SUBARCH_SET_SINGLESTEPPING
  28         SUBARCH_SET_SINGLESTEPPING(child, 0);
  29 #endif
  30 }
  31
  32 /*
  33  * Called by kernel/ptrace.c when detaching..
  34  */
  35 void ptrace_disable(struct task_struct *child)
  36 {
  37         user_disable_single_step(child);
  38 }
  39
  40 extern int peek_user(struct task_struct * child, long addr, long data);
  41 extern int poke_user(struct task_struct * child, long addr, long data);
  42
  43 long arch_ptrace(struct task_struct *child, long request,
  44                  unsigned long addr, unsigned long data)
  45 {
  46         int i, ret;
  47         unsigned long __user *p = (void __user *)data;
  48         void __user *vp = p;
  49
  50         switch (request) {
  51         /* read the word at location addr in the USER area. */
  52         case PTRACE_PEEKUSR:
  53                 ret = peek_user(child, addr, data);
  54                 break;
  55
  56         /* write the word at location addr in the USER area */
  57         case PTRACE_POKEUSR:
  58                 ret = poke_user(child, addr, data);
  59                 break;
  60
  61         case PTRACE_SYSEMU:
  62         case PTRACE_SYSEMU_SINGLESTEP:
  63                 ret = -EIO;
  64                 break;
  65
  66 #ifdef PTRACE_GETREGS
  67         case PTRACE_GETREGS: { /* Get all gp regs from the child. */
  68                 if (!access_ok(p, MAX_REG_OFFSET)) {
  69                         ret = -EIO;
  70                         break;
  71                 }
  72                 for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
  73                         __put_user(getreg(child, i), p);
  74                         p++;
  75                 }
  76                 ret = 0;
  77                 break;
  78         }
  79 #endif
  80 #ifdef PTRACE_SETREGS
  81         case PTRACE_SETREGS: { /* Set all gp regs in the child. */
  82                 unsigned long tmp = 0;
  83                 if (!access_ok(p, MAX_REG_OFFSET)) {
  84                         ret = -EIO;
  85                         break;
  86                 }
  87                 for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
  88                         __get_user(tmp, p);
  89                         putreg(child, i, tmp);
  90                         p++;
  91                 }
  92                 ret = 0;
  93                 break;
  94         }
  95 #endif
  96         case PTRACE_GET_THREAD_AREA:
  97                 ret = ptrace_get_thread_area(child, addr, vp);
  98                 break;
  99
 100         case PTRACE_SET_THREAD_AREA:
 101                 ret = ptrace_set_thread_area(child, addr, vp);
 102                 break;
 103
 104         default:
 105                 ret = ptrace_request(child, request, addr, data);
 106                 if (ret == -EIO)
 107                         ret = subarch_ptrace(child, request, addr, data);
 108                 break;
 109         }
 110
 111         return ret;
 112 }
 113
 114 static void send_sigtrap(struct uml_pt_regs *regs, int error_code)
 115 {
 116         /* Send us the fake SIGTRAP */
 117         force_sig_fault(SIGTRAP, TRAP_BRKPT,
 118                         /* User-mode eip? */
 119                         UPT_IS_USER(regs) ? (void __user *) UPT_IP(regs) : NULL);
 120 }
 121
 122 /*
 123  * XXX Check TIF_SINGLESTEP for singlestepping check and
 124  * PT_PTRACED vs TIF_SYSCALL_TRACE for syscall tracing check
 125  */
 126 int syscall_trace_enter(struct pt_regs *regs)
 127 {
 128         audit_syscall_entry(UPT_SYSCALL_NR(&regs->regs),
 129                             UPT_SYSCALL_ARG1(&regs->regs),
 130                             UPT_SYSCALL_ARG2(&regs->regs),
 131                             UPT_SYSCALL_ARG3(&regs->regs),
 132                             UPT_SYSCALL_ARG4(&regs->regs));
 133
 134         if (!test_thread_flag(TIF_SYSCALL_TRACE))
 135                 return 0;
 136
 137         return ptrace_report_syscall_entry(regs);
 138 }
 139
 140 void syscall_trace_leave(struct pt_regs *regs)
 141 {
 142         int ptraced = current->ptrace;
 143
 144         audit_syscall_exit(regs);
 145
 146         /* Fake a debug trap */
 147         if (test_thread_flag(TIF_SINGLESTEP))
 148                 send_sigtrap(&regs->regs, 0);
 149
 150         if (!test_thread_flag(TIF_SYSCALL_TRACE))
 151                 return;
 152
 153         ptrace_report_syscall_exit(regs, 0);
 154         /* force do_signal() --> is_syscall() */
 155         if (ptraced & PT_PTRACED)
 156                 set_thread_flag(TIF_SIGPENDING);
 157 }