arch/metag/kernel/ptrace.c

   1 /*
   2  *  Copyright (C) 2005-2012 Imagination Technologies Ltd.
   3  *
   4  * This file is subject to the terms and conditions of the GNU General
   5  * Public License.  See the file COPYING in the main directory of
   6  * this archive for more details.
   7  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/mm.h>
  11 #include <linux/errno.h>
  12 #include <linux/ptrace.h>
  13 #include <linux/user.h>
  14 #include <linux/regset.h>
  15 #include <linux/tracehook.h>
  16 #include <linux/elf.h>
  17 #include <linux/uaccess.h>
  18 #include <trace/syscall.h>
  19
  20 #define CREATE_TRACE_POINTS
  21 #include <trace/events/syscalls.h>
  22
  23 /*
  24  * user_regset definitions.
  25  */
  26
  27 static unsigned long user_txstatus(const struct pt_regs *regs)
  28 {
  29         unsigned long data = (unsigned long)regs->ctx.Flags;
  30
  31         if (regs->ctx.SaveMask & TBICTX_CBUF_BIT)
  32                 data |= USER_GP_REGS_STATUS_CATCH_BIT;
  33
  34         return data;
  35 }
  36
  37 int metag_gp_regs_copyout(const struct pt_regs *regs,
  38                           unsigned int pos, unsigned int count,
  39                           void *kbuf, void __user *ubuf)
  40 {
  41         const void *ptr;
  42         unsigned long data;
  43         int ret;
  44
  45         /* D{0-1}.{0-7} */
  46         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
  47                                   regs->ctx.DX, 0, 4*16);
  48         if (ret)
  49                 goto out;
  50         /* A{0-1}.{0-1} */
  51         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
  52                                   regs->ctx.AX, 4*16, 4*20);
  53         if (ret)
  54                 goto out;
  55         /* A{0-1}.2 */
  56         if (regs->ctx.SaveMask & TBICTX_XEXT_BIT)
  57                 ptr = regs->ctx.Ext.Ctx.pExt;
  58         else
  59                 ptr = &regs->ctx.Ext.AX2;
  60         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
  61                                   ptr, 4*20, 4*22);
  62         if (ret)
  63                 goto out;
  64         /* A{0-1}.3 */
  65         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
  66                                   &regs->ctx.AX3, 4*22, 4*24);
  67         if (ret)
  68                 goto out;
  69         /* PC */
  70         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
  71                                   &regs->ctx.CurrPC, 4*24, 4*25);
  72         if (ret)
  73                 goto out;
  74         /* TXSTATUS */
  75         data = user_txstatus(regs);
  76         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
  77                                   &data, 4*25, 4*26);
  78         if (ret)
  79                 goto out;
  80         /* TXRPT, TXBPOBITS, TXMODE */
  81         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
  82                                   &regs->ctx.CurrRPT, 4*26, 4*29);
  83         if (ret)
  84                 goto out;
  85         /* Padding */
  86         ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
  87                                        4*29, 4*30);
  88 out:
  89         return ret;
  90 }
  91
  92 int metag_gp_regs_copyin(struct pt_regs *regs,
  93                          unsigned int pos, unsigned int count,
  94                          const void *kbuf, const void __user *ubuf)
  95 {
  96         void *ptr;
  97         unsigned long data;
  98         int ret;
  99
 100         /* D{0-1}.{0-7} */
 101         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 102                                  regs->ctx.DX, 0, 4*16);
 103         if (ret)
 104                 goto out;
 105         /* A{0-1}.{0-1} */
 106         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 107                                  regs->ctx.AX, 4*16, 4*20);
 108         if (ret)
 109                 goto out;
 110         /* A{0-1}.2 */
 111         if (regs->ctx.SaveMask & TBICTX_XEXT_BIT)
 112                 ptr = regs->ctx.Ext.Ctx.pExt;
 113         else
 114                 ptr = &regs->ctx.Ext.AX2;
 115         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 116                                  ptr, 4*20, 4*22);
 117         if (ret)
 118                 goto out;
 119         /* A{0-1}.3 */
 120         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 121                                  &regs->ctx.AX3, 4*22, 4*24);
 122         if (ret)
 123                 goto out;
 124         /* PC */
 125         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 126                                  &regs->ctx.CurrPC, 4*24, 4*25);
 127         if (ret)
 128                 goto out;
 129         /* TXSTATUS */
 130         data = user_txstatus(regs);
 131         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 132                                  &data, 4*25, 4*26);
 133         if (ret)
 134                 goto out;
 135         regs->ctx.Flags = data & 0xffff;
 136         if (data & USER_GP_REGS_STATUS_CATCH_BIT)
 137                 regs->ctx.SaveMask |= TBICTX_XCBF_BIT | TBICTX_CBUF_BIT;
 138         else
 139                 regs->ctx.SaveMask &= ~TBICTX_CBUF_BIT;
 140         /* TXRPT, TXBPOBITS, TXMODE */
 141         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 142                                  &regs->ctx.CurrRPT, 4*26, 4*29);
 143 out:
 144         return ret;
 145 }
 146
 147 static int metag_gp_regs_get(struct task_struct *target,
 148                              const struct user_regset *regset,
 149                              unsigned int pos, unsigned int count,
 150                              void *kbuf, void __user *ubuf)
 151 {
 152         const struct pt_regs *regs = task_pt_regs(target);
 153         return metag_gp_regs_copyout(regs, pos, count, kbuf, ubuf);
 154 }
 155
 156 static int metag_gp_regs_set(struct task_struct *target,
 157                              const struct user_regset *regset,
 158                              unsigned int pos, unsigned int count,
 159                              const void *kbuf, const void __user *ubuf)
 160 {
 161         struct pt_regs *regs = task_pt_regs(target);
 162         return metag_gp_regs_copyin(regs, pos, count, kbuf, ubuf);
 163 }
 164
 165 int metag_cb_regs_copyout(const struct pt_regs *regs,
 166                           unsigned int pos, unsigned int count,
 167                           void *kbuf, void __user *ubuf)
 168 {
 169         int ret;
 170
 171         /* TXCATCH{0-3} */
 172         if (regs->ctx.SaveMask & TBICTX_XCBF_BIT)
 173                 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
 174                                           regs->extcb0, 0, 4*4);
 175         else
 176                 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
 177                                                0, 4*4);
 178         return ret;
 179 }
 180
 181 int metag_cb_regs_copyin(struct pt_regs *regs,
 182                          unsigned int pos, unsigned int count,
 183                          const void *kbuf, const void __user *ubuf)
 184 {
 185         int ret;
 186
 187         /* TXCATCH{0-3} */
 188         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 189                                  regs->extcb0, 0, 4*4);
 190         return ret;
 191 }
 192
 193 static int metag_cb_regs_get(struct task_struct *target,
 194                              const struct user_regset *regset,
 195                              unsigned int pos, unsigned int count,
 196                              void *kbuf, void __user *ubuf)
 197 {
 198         const struct pt_regs *regs = task_pt_regs(target);
 199         return metag_cb_regs_copyout(regs, pos, count, kbuf, ubuf);
 200 }
 201
 202 static int metag_cb_regs_set(struct task_struct *target,
 203                              const struct user_regset *regset,
 204                              unsigned int pos, unsigned int count,
 205                              const void *kbuf, const void __user *ubuf)
 206 {
 207         struct pt_regs *regs = task_pt_regs(target);
 208         return metag_cb_regs_copyin(regs, pos, count, kbuf, ubuf);
 209 }
 210
 211 int metag_rp_state_copyout(const struct pt_regs *regs,
 212                            unsigned int pos, unsigned int count,
 213                            void *kbuf, void __user *ubuf)
 214 {
 215         unsigned long mask;
 216         u64 *ptr;
 217         int ret, i;
 218
 219         /* Empty read pipeline */
 220         if (!(regs->ctx.SaveMask & TBICTX_CBRP_BIT)) {
 221                 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
 222                                                0, 4*13);
 223                 goto out;
 224         }
 225
 226         mask = (regs->ctx.CurrDIVTIME & TXDIVTIME_RPMASK_BITS) >>
 227                 TXDIVTIME_RPMASK_S;
 228
 229         /* Read pipeline entries */
 230         ptr = (void *)&regs->extcb0[1];
 231         for (i = 0; i < 6; ++i, ++ptr) {
 232                 if (mask & (1 << i))
 233                         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
 234                                                   ptr, 8*i, 8*(i + 1));
 235                 else
 236                         ret = user_regset_copyout_zero(&pos, &count, &kbuf,
 237                                                        &ubuf, 8*i, 8*(i + 1));
 238                 if (ret)
 239                         goto out;
 240         }
 241         /* Mask of entries */
 242         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
 243                                   &mask, 4*12, 4*13);
 244 out:
 245         return ret;
 246 }
 247
 248 int metag_rp_state_copyin(struct pt_regs *regs,
 249                           unsigned int pos, unsigned int count,
 250                           const void *kbuf, const void __user *ubuf)
 251 {
 252         struct user_rp_state rp;
 253         unsigned long long *ptr;
 254         int ret, i;
 255
 256         if (count < 4*13)
 257                 return -EINVAL;
 258         /* Read the entire pipeline before making any changes */
 259         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 260                                  &rp, 0, 4*13);
 261         if (ret)
 262                 goto out;
 263
 264         /* Write pipeline entries */
 265         ptr = (void *)&regs->extcb0[1];
 266         for (i = 0; i < 6; ++i, ++ptr)
 267                 if (rp.mask & (1 << i))
 268                         *ptr = rp.entries[i];
 269
 270         /* Update RPMask in TXDIVTIME */
 271         regs->ctx.CurrDIVTIME &= ~TXDIVTIME_RPMASK_BITS;
 272         regs->ctx.CurrDIVTIME |= (rp.mask << TXDIVTIME_RPMASK_S)
 273                                  & TXDIVTIME_RPMASK_BITS;
 274
 275         /* Set/clear flags to indicate catch/read pipeline state */
 276         if (rp.mask)
 277                 regs->ctx.SaveMask |= TBICTX_XCBF_BIT | TBICTX_CBRP_BIT;
 278         else
 279                 regs->ctx.SaveMask &= ~TBICTX_CBRP_BIT;
 280 out:
 281         return ret;
 282 }
 283
 284 static int metag_rp_state_get(struct task_struct *target,
 285                               const struct user_regset *regset,
 286                               unsigned int pos, unsigned int count,
 287                               void *kbuf, void __user *ubuf)
 288 {
 289         const struct pt_regs *regs = task_pt_regs(target);
 290         return metag_rp_state_copyout(regs, pos, count, kbuf, ubuf);
 291 }
 292
 293 static int metag_rp_state_set(struct task_struct *target,
 294                               const struct user_regset *regset,
 295                               unsigned int pos, unsigned int count,
 296                               const void *kbuf, const void __user *ubuf)
 297 {
 298         struct pt_regs *regs = task_pt_regs(target);
 299         return metag_rp_state_copyin(regs, pos, count, kbuf, ubuf);
 300 }
 301
 302 static int metag_tls_get(struct task_struct *target,
 303                         const struct user_regset *regset,
 304                         unsigned int pos, unsigned int count,
 305                         void *kbuf, void __user *ubuf)
 306 {
 307         void __user *tls = target->thread.tls_ptr;
 308         return user_regset_copyout(&pos, &count, &kbuf, &ubuf, &tls, 0, -1);
 309 }
 310
 311 static int metag_tls_set(struct task_struct *target,
 312                         const struct user_regset *regset,
 313                         unsigned int pos, unsigned int count,
 314                         const void *kbuf, const void __user *ubuf)
 315 {
 316         int ret;
 317         void __user *tls = target->thread.tls_ptr;
 318
 319         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &tls, 0, -1);
 320         if (ret)
 321                 return ret;
 322
 323         target->thread.tls_ptr = tls;
 324         return ret;
 325 }
 326
 327 enum metag_regset {
 328         REGSET_GENERAL,
 329         REGSET_CBUF,
 330         REGSET_READPIPE,
 331         REGSET_TLS,
 332 };
 333
 334 static const struct user_regset metag_regsets[] = {
 335         [REGSET_GENERAL] = {
 336                 .core_note_type = NT_PRSTATUS,
 337                 .n = ELF_NGREG,
 338                 .size = sizeof(long),
 339                 .align = sizeof(long long),
 340                 .get = metag_gp_regs_get,
 341                 .set = metag_gp_regs_set,
 342         },
 343         [REGSET_CBUF] = {
 344                 .core_note_type = NT_METAG_CBUF,
 345                 .n = sizeof(struct user_cb_regs) / sizeof(long),
 346                 .size = sizeof(long),
 347                 .align = sizeof(long long),
 348                 .get = metag_cb_regs_get,
 349                 .set = metag_cb_regs_set,
 350         },
 351         [REGSET_READPIPE] = {
 352                 .core_note_type = NT_METAG_RPIPE,
 353                 .n = sizeof(struct user_rp_state) / sizeof(long),
 354                 .size = sizeof(long),
 355                 .align = sizeof(long long),
 356                 .get = metag_rp_state_get,
 357                 .set = metag_rp_state_set,
 358         },
 359         [REGSET_TLS] = {
 360                 .core_note_type = NT_METAG_TLS,
 361                 .n = 1,
 362                 .size = sizeof(void *),
 363                 .align = sizeof(void *),
 364                 .get = metag_tls_get,
 365                 .set = metag_tls_set,
 366         },
 367 };
 368
 369 static const struct user_regset_view user_metag_view = {
 370         .name = "metag",
 371         .e_machine = EM_METAG,
 372         .regsets = metag_regsets,
 373         .n = ARRAY_SIZE(metag_regsets)
 374 };
 375
 376 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
 377 {
 378         return &user_metag_view;
 379 }
 380
 381 /*
 382  * Called by kernel/ptrace.c when detaching..
 383  *
 384  * Make sure single step bits etc are not set.
 385  */
 386 void ptrace_disable(struct task_struct *child)
 387 {
 388         /* nothing to do.. */
 389 }
 390
 391 long arch_ptrace(struct task_struct *child, long request, unsigned long addr,
 392                  unsigned long data)
 393 {
 394         int ret;
 395
 396         switch (request) {
 397         default:
 398                 ret = ptrace_request(child, request, addr, data);
 399                 break;
 400         }
 401
 402         return ret;
 403 }
 404
 405 int syscall_trace_enter(struct pt_regs *regs)
 406 {
 407         int ret = 0;
 408
 409         if (test_thread_flag(TIF_SYSCALL_TRACE))
 410                 ret = tracehook_report_syscall_entry(regs);
 411
 412         if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
 413                 trace_sys_enter(regs, regs->ctx.DX[0].U1);
 414
 415         return ret ? -1 : regs->ctx.DX[0].U1;
 416 }
 417
 418 void syscall_trace_leave(struct pt_regs *regs)
 419 {
 420         if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
 421                 trace_sys_exit(regs, regs->ctx.DX[0].U1);
 422
 423         if (test_thread_flag(TIF_SYSCALL_TRACE))
 424                 tracehook_report_syscall_exit(regs, 0);
 425 }