arch/riscv/kernel/ptrace.c

   1 /*
   2  * Copyright 2010 Tilera Corporation. All Rights Reserved.
   3  * Copyright 2015 Regents of the University of California
   4  * Copyright 2017 SiFive
   5  *
   6  *   This program is free software; you can redistribute it and/or
   7  *   modify it under the terms of the GNU General Public License
   8  *   as published by the Free Software Foundation, version 2.
   9  *
  10  *   This program is distributed in the hope that it will be useful,
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *   GNU General Public License for more details.
  14  *
  15  * Copied from arch/tile/kernel/ptrace.c
  16  */
  17
  18 #include <asm/ptrace.h>
  19 #include <asm/syscall.h>
  20 #include <asm/thread_info.h>
  21 #include <linux/audit.h>
  22 #include <linux/ptrace.h>
  23 #include <linux/elf.h>
  24 #include <linux/regset.h>
  25 #include <linux/sched.h>
  26 #include <linux/sched/task_stack.h>
  27 #include <linux/tracehook.h>
  28
  29 #define CREATE_TRACE_POINTS
  30 #include <trace/events/syscalls.h>
  31
  32 enum riscv_regset {
  33         REGSET_X,
  34 #ifdef CONFIG_FPU
  35         REGSET_F,
  36 #endif
  37 };
  38
  39 static int riscv_gpr_get(struct task_struct *target,
  40                          const struct user_regset *regset,
  41                          unsigned int pos, unsigned int count,
  42                          void *kbuf, void __user *ubuf)
  43 {
  44         struct pt_regs *regs;
  45
  46         regs = task_pt_regs(target);
  47         return user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs, 0, -1);
  48 }
  49
  50 static int riscv_gpr_set(struct task_struct *target,
  51                          const struct user_regset *regset,
  52                          unsigned int pos, unsigned int count,
  53                          const void *kbuf, const void __user *ubuf)
  54 {
  55         int ret;
  56         struct pt_regs *regs;
  57
  58         regs = task_pt_regs(target);
  59         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, regs, 0, -1);
  60         return ret;
  61 }
  62
  63 #ifdef CONFIG_FPU
  64 static int riscv_fpr_get(struct task_struct *target,
  65                          const struct user_regset *regset,
  66                          unsigned int pos, unsigned int count,
  67                          void *kbuf, void __user *ubuf)
  68 {
  69         int ret;
  70         struct __riscv_d_ext_state *fstate = &target->thread.fstate;
  71
  72         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, fstate, 0,
  73                                   offsetof(struct __riscv_d_ext_state, fcsr));
  74         if (!ret) {
  75                 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, fstate, 0,
  76                                           offsetof(struct __riscv_d_ext_state, fcsr) +
  77                                           sizeof(fstate->fcsr));
  78         }
  79
  80         return ret;
  81 }
  82
  83 static int riscv_fpr_set(struct task_struct *target,
  84                          const struct user_regset *regset,
  85                          unsigned int pos, unsigned int count,
  86                          const void *kbuf, const void __user *ubuf)
  87 {
  88         int ret;
  89         struct __riscv_d_ext_state *fstate = &target->thread.fstate;
  90
  91         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, fstate, 0,
  92                                  offsetof(struct __riscv_d_ext_state, fcsr));
  93         if (!ret) {
  94                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, fstate, 0,
  95                                          offsetof(struct __riscv_d_ext_state, fcsr) +
  96                                          sizeof(fstate->fcsr));
  97         }
  98
  99         return ret;
 100 }
 101 #endif
 102
 103 static const struct user_regset riscv_user_regset[] = {
 104         [REGSET_X] = {
 105                 .core_note_type = NT_PRSTATUS,
 106                 .n = ELF_NGREG,
 107                 .size = sizeof(elf_greg_t),
 108                 .align = sizeof(elf_greg_t),
 109                 .get = &riscv_gpr_get,
 110                 .set = &riscv_gpr_set,
 111         },
 112 #ifdef CONFIG_FPU
 113         [REGSET_F] = {
 114                 .core_note_type = NT_PRFPREG,
 115                 .n = ELF_NFPREG,
 116                 .size = sizeof(elf_fpreg_t),
 117                 .align = sizeof(elf_fpreg_t),
 118                 .get = &riscv_fpr_get,
 119                 .set = &riscv_fpr_set,
 120         },
 121 #endif
 122 };
 123
 124 static const struct user_regset_view riscv_user_native_view = {
 125         .name = "riscv",
 126         .e_machine = EM_RISCV,
 127         .regsets = riscv_user_regset,
 128         .n = ARRAY_SIZE(riscv_user_regset),
 129 };
 130
 131 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
 132 {
 133         return &riscv_user_native_view;
 134 }
 135
 136 void ptrace_disable(struct task_struct *child)
 137 {
 138         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 139 }
 140
 141 long arch_ptrace(struct task_struct *child, long request,
 142                  unsigned long addr, unsigned long data)
 143 {
 144         long ret = -EIO;
 145
 146         switch (request) {
 147         default:
 148                 ret = ptrace_request(child, request, addr, data);
 149                 break;
 150         }
 151
 152         return ret;
 153 }
 154
 155 /*
 156  * Allows PTRACE_SYSCALL to work.  These are called from entry.S in
 157  * {handle,ret_from}_syscall.
 158  */
 159 void do_syscall_trace_enter(struct pt_regs *regs)
 160 {
 161         if (test_thread_flag(TIF_SYSCALL_TRACE))
 162                 if (tracehook_report_syscall_entry(regs))
 163                         syscall_set_nr(current, regs, -1);
 164
 165 #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
 166         if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
 167                 trace_sys_enter(regs, syscall_get_nr(current, regs));
 168 #endif
 169
 170         audit_syscall_entry(regs->a7, regs->a0, regs->a1, regs->a2, regs->a3);
 171 }
 172
 173 void do_syscall_trace_exit(struct pt_regs *regs)
 174 {
 175         audit_syscall_exit(regs);
 176
 177         if (test_thread_flag(TIF_SYSCALL_TRACE))
 178                 tracehook_report_syscall_exit(regs, 0);
 179
 180 #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
 181         if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
 182                 trace_sys_exit(regs, regs_return_value(regs));
 183 #endif
 184 }