root/arch/h8300/kernel/ptrace.c

DEFINITIONS

1. h8300_get_reg
2. h8300_put_reg
3. regs_get
4. regs_set
5. task_user_regset_view
6. ptrace_disable
7. arch_ptrace
8. do_syscall_trace_enter
9. do_syscall_trace_leave

   1 /*
   2  *  linux/arch/h8300/kernel/ptrace.c
   3  *
   4  *  Copyright 2015 Yoshinori Sato <ysato@users.sourceforge.jp>
   5  *
   6  * This file is subject to the terms and conditions of the GNU General
   7  * Public License.  See the file COPYING in the main directory of
   8  * this archive for more details.
   9  */
  10 
  11 #include <linux/kernel.h>
  12 #include <linux/errno.h>
  13 #include <linux/ptrace.h>
  14 #include <linux/audit.h>
  15 #include <linux/tracehook.h>
  16 #include <linux/regset.h>
  17 #include <linux/elf.h>
  18 
  19 #define CCR_MASK 0x6f    /* mode/imask not set */
  20 #define EXR_MASK 0x80    /* modify only T */
  21 
  22 #define PT_REG(r) offsetof(struct pt_regs, r)
  23 
  24 extern void user_disable_single_step(struct task_struct *child);
  25 
  26 /* Mapping from PT_xxx to the stack offset at which the register is
  27    saved.  Notice that usp has no stack-slot and needs to be treated
  28    specially (see get_reg/put_reg below). */
  29 static const int register_offset[] = {
  30         PT_REG(er1), PT_REG(er2), PT_REG(er3), PT_REG(er4),
  31         PT_REG(er5), PT_REG(er6), PT_REG(er0), -1,
  32         PT_REG(orig_er0), PT_REG(ccr), PT_REG(pc),
  33 #if defined(CONFIG_CPU_H8S)
  34         PT_REG(exr),
  35 #endif
  36 };
  37 
  38 /* read register */
  39 long h8300_get_reg(struct task_struct *task, int regno)
  40 {
  41         switch (regno) {
  42         case PT_USP:
  43                 return task->thread.usp + sizeof(long)*2;
  44         case PT_CCR:
  45         case PT_EXR:
  46             return *(unsigned short *)(task->thread.esp0 +
  47                                        register_offset[regno]);
  48         default:
  49             return *(unsigned long *)(task->thread.esp0 +
  50                                       register_offset[regno]);
  51         }
  52 }
  53 
  54 int h8300_put_reg(struct task_struct *task, int regno, unsigned long data)
  55 {
  56         unsigned short oldccr;
  57         unsigned short oldexr;
  58 
  59         switch (regno) {
  60         case PT_USP:
  61                 task->thread.usp = data - sizeof(long)*2;
  62         case PT_CCR:
  63                 oldccr = *(unsigned short *)(task->thread.esp0 +
  64                                              register_offset[regno]);
  65                 oldccr &= ~CCR_MASK;
  66                 data &= CCR_MASK;
  67                 data |= oldccr;
  68                 *(unsigned short *)(task->thread.esp0 +
  69                                     register_offset[regno]) = data;
  70                 break;
  71         case PT_EXR:
  72                 oldexr = *(unsigned short *)(task->thread.esp0 +
  73                                              register_offset[regno]);
  74                 oldccr &= ~EXR_MASK;
  75                 data &= EXR_MASK;
  76                 data |= oldexr;
  77                 *(unsigned short *)(task->thread.esp0 +
  78                                     register_offset[regno]) = data;
  79                 break;
  80         default:
  81                 *(unsigned long *)(task->thread.esp0 +
  82                                    register_offset[regno]) = data;
  83                 break;
  84         }
  85         return 0;
  86 }
  87 
  88 static int regs_get(struct task_struct *target,
  89                     const struct user_regset *regset,
  90                     unsigned int pos, unsigned int count,
  91                     void *kbuf, void __user *ubuf)
  92 {
  93         int r;
  94         struct user_regs_struct regs;
  95         long *reg = (long *)&regs;
  96 
  97         /* build user regs in buffer */
  98         BUILD_BUG_ON(sizeof(regs) % sizeof(long) != 0);
  99         for (r = 0; r < sizeof(regs) / sizeof(long); r++)
 100                 *reg++ = h8300_get_reg(target, r);
 101 
 102         return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
 103                                    &regs, 0, sizeof(regs));
 104 }
 105 
 106 static int regs_set(struct task_struct *target,
 107                     const struct user_regset *regset,
 108                     unsigned int pos, unsigned int count,
 109                     const void *kbuf, const void __user *ubuf)
 110 {
 111         int r;
 112         int ret;
 113         struct user_regs_struct regs;
 114         long *reg;
 115 
 116         /* build user regs in buffer */
 117         BUILD_BUG_ON(sizeof(regs) % sizeof(long) != 0);
 118         for (reg = (long *)&regs, r = 0; r < sizeof(regs) / sizeof(long); r++)
 119                 *reg++ = h8300_get_reg(target, r);
 120 
 121         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 122                                  &regs, 0, sizeof(regs));
 123         if (ret)
 124                 return ret;
 125 
 126         /* write back to pt_regs */
 127         for (reg = (long *)&regs, r = 0; r < sizeof(regs) / sizeof(long); r++)
 128                 h8300_put_reg(target, r, *reg++);
 129         return 0;
 130 }
 131 
 132 enum h8300_regset {
 133         REGSET_GENERAL,
 134 };
 135 
 136 static const struct user_regset h8300_regsets[] = {
 137         [REGSET_GENERAL] = {
 138                 .core_note_type = NT_PRSTATUS,
 139                 .n              = ELF_NGREG,
 140                 .size           = sizeof(long),
 141                 .align          = sizeof(long),
 142                 .get            = regs_get,
 143                 .set            = regs_set,
 144         },
 145 };
 146 
 147 static const struct user_regset_view user_h8300_native_view = {
 148         .name = "h8300",
 149         .e_machine = EM_H8_300,
 150         .regsets = h8300_regsets,
 151         .n = ARRAY_SIZE(h8300_regsets),
 152 };
 153 
 154 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
 155 {
 156         return &user_h8300_native_view;
 157 }
 158 
 159 void ptrace_disable(struct task_struct *child)
 160 {
 161         user_disable_single_step(child);
 162 }
 163 
 164 long arch_ptrace(struct task_struct *child, long request,
 165                  unsigned long addr, unsigned long data)
 166 {
 167         int ret;
 168 
 169         switch (request) {
 170         default:
 171                 ret = ptrace_request(child, request, addr, data);
 172                 break;
 173         }
 174         return ret;
 175 }
 176 
 177 asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
 178 {
 179         long ret = 0;
 180 
 181         if (test_thread_flag(TIF_SYSCALL_TRACE) &&
 182             tracehook_report_syscall_entry(regs))
 183                 /*
 184                  * Tracing decided this syscall should not happen.
 185                  * We'll return a bogus call number to get an ENOSYS
 186                  * error, but leave the original number in regs->regs[0].
 187                  */
 188                 ret = -1L;
 189 
 190         audit_syscall_entry(regs->er1, regs->er2, regs->er3,
 191                             regs->er4, regs->er5);
 192 
 193         return ret ?: regs->er0;
 194 }
 195 
 196 asmlinkage void do_syscall_trace_leave(struct pt_regs *regs)
 197 {
 198         int step;
 199 
 200         audit_syscall_exit(regs);
 201 
 202         step = test_thread_flag(TIF_SINGLESTEP);
 203         if (step || test_thread_flag(TIF_SYSCALL_TRACE))
 204                 tracehook_report_syscall_exit(regs, step);
 205 }