git.oblomov.eu Git - linux-2.6/blob - arch/cris/arch-v32/kernel/ptrace.c

   1 /*
   2  * Copyright (C) 2000-2003, Axis Communications AB.
   3  */
   4
   5 #include <linux/kernel.h>
   6 #include <linux/sched.h>
   7 #include <linux/mm.h>
   8 #include <linux/smp.h>
   9 #include <linux/smp_lock.h>
  10 #include <linux/errno.h>
  11 #include <linux/ptrace.h>
  12 #include <linux/user.h>
  13 #include <linux/signal.h>
  14 #include <linux/security.h>
  15
  16 #include <asm/uaccess.h>
  17 #include <asm/page.h>
  18 #include <asm/pgtable.h>
  19 #include <asm/system.h>
  20 #include <asm/processor.h>
  21 #include <asm/arch/hwregs/supp_reg.h>
  22
  23 /*
  24  * Determines which bits in CCS the user has access to.
  25  * 1 = access, 0 = no access.
  26  */
  27 #define CCS_MASK 0x00087c00     /* SXNZVC */
  28
  29 #define SBIT_USER (1 << (S_CCS_BITNR + CCS_SHIFT))
  30
  31 static int put_debugreg(long pid, unsigned int regno, long data);
  32 static long get_debugreg(long pid, unsigned int regno);
  33 static unsigned long get_pseudo_pc(struct task_struct *child);
  34 void deconfigure_bp(long pid);
  35
  36 extern unsigned long cris_signal_return_page;
  37
  38 /*
  39  * Get contents of register REGNO in task TASK.
  40  */
  41 long get_reg(struct task_struct *task, unsigned int regno)
  42 {
  43         /* USP is a special case, it's not in the pt_regs struct but
  44          * in the tasks thread struct
  45          */
  46         unsigned long ret;
  47
  48         if (regno <= PT_EDA)
  49                 ret = ((unsigned long *)task_pt_regs(task))[regno];
  50         else if (regno == PT_USP)
  51                 ret = task->thread.usp;
  52         else if (regno == PT_PPC)
  53                 ret = get_pseudo_pc(task);
  54         else if (regno <= PT_MAX)
  55                 ret = get_debugreg(task->pid, regno);
  56         else
  57                 ret = 0;
  58
  59         return ret;
  60 }
  61
  62 /*
  63  * Write contents of register REGNO in task TASK.
  64  */
  65 int put_reg(struct task_struct *task, unsigned int regno, unsigned long data)
  66 {
  67         if (regno <= PT_EDA)
  68                 ((unsigned long *)task_pt_regs(task))[regno] = data;
  69         else if (regno == PT_USP)
  70                 task->thread.usp = data;
  71         else if (regno == PT_PPC) {
  72                 /* Write pseudo-PC to ERP only if changed. */
  73                 if (data != get_pseudo_pc(task))
  74                         task_pt_regs(task)->erp = data;
  75         } else if (regno <= PT_MAX)
  76                 return put_debugreg(task->pid, regno, data);
  77         else
  78                 return -1;
  79         return 0;
  80 }
  81
  82 /*
  83  * Called by kernel/ptrace.c when detaching.
  84  *
  85  * Make sure the single step bit is not set.
  86  */
  87 void
  88 ptrace_disable(struct task_struct *child)
  89 {
  90         unsigned long tmp;
  91
  92         /* Deconfigure SPC and S-bit. */
  93         tmp = get_reg(child, PT_CCS) & ~SBIT_USER;
  94         put_reg(child, PT_CCS, tmp);
  95         put_reg(child, PT_SPC, 0);
  96
  97         /* Deconfigure any watchpoints associated with the child. */
  98         deconfigure_bp(child->pid);
  99 }
 100
 101
 102 long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 103 {
 104         int ret;
 105         unsigned long __user *datap = (unsigned long __user *)data;
 106
 107         switch (request) {
 108                 /* Read word at location address. */
 109                 case PTRACE_PEEKTEXT:
 110                 case PTRACE_PEEKDATA: {
 111                         unsigned long tmp;
 112                         int copied;
 113
 114                         ret = -EIO;
 115
 116                         /* The signal trampoline page is outside the normal user-addressable
 117                          * space but still accessible. This is hack to make it possible to
 118                          * access the signal handler code in GDB.
 119                          */
 120                         if ((addr & PAGE_MASK) == cris_signal_return_page) {
 121                                 /* The trampoline page is globally mapped, no page table to traverse.*/
 122                                 tmp = *(unsigned long*)addr;
 123                         } else {
 124                                 copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
 125
 126                                 if (copied != sizeof(tmp))
 127                                         break;
 128                         }
 129
 130                         ret = put_user(tmp,datap);
 131                         break;
 132                 }
 133
 134                 /* Read the word at location address in the USER area. */
 135                 case PTRACE_PEEKUSR: {
 136                         unsigned long tmp;
 137
 138                         ret = -EIO;
 139                         if ((addr & 3) || addr < 0 || addr > PT_MAX << 2)
 140                                 break;
 141
 142                         tmp = get_reg(child, addr >> 2);
 143                         ret = put_user(tmp, datap);
 144                         break;
 145                 }
 146
 147                 /* Write the word at location address. */
 148                 case PTRACE_POKETEXT:
 149                 case PTRACE_POKEDATA:
 150                         ret = 0;
 151
 152                         if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data))
 153                                 break;
 154
 155                         ret = -EIO;
 156                         break;
 157
 158                 /* Write the word at location address in the USER area. */
 159                 case PTRACE_POKEUSR:
 160                         ret = -EIO;
 161                         if ((addr & 3) || addr < 0 || addr > PT_MAX << 2)
 162                                 break;
 163
 164                         addr >>= 2;
 165
 166                         if (addr == PT_CCS) {
 167                                 /* don't allow the tracing process to change stuff like
 168                                  * interrupt enable, kernel/user bit, dma enables etc.
 169                                  */
 170                                 data &= CCS_MASK;
 171                                 data |= get_reg(child, PT_CCS) & ~CCS_MASK;
 172                         }
 173                         if (put_reg(child, addr, data))
 174                                 break;
 175                         ret = 0;
 176                         break;
 177
 178                 case PTRACE_SYSCALL:
 179                 case PTRACE_CONT:
 180                         ret = -EIO;
 181
 182                         if (!valid_signal(data))
 183                                 break;
 184
 185                         /* Continue means no single-step. */
 186                         put_reg(child, PT_SPC, 0);
 187
 188                         if (!get_debugreg(child->pid, PT_BP_CTRL)) {
 189                                 unsigned long tmp;
 190                                 /* If no h/w bp configured, disable S bit. */
 191                                 tmp = get_reg(child, PT_CCS) & ~SBIT_USER;
 192                                 put_reg(child, PT_CCS, tmp);
 193                         }
 194
 195                         if (request == PTRACE_SYSCALL) {
 196                                 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 197                         }
 198                         else {
 199                                 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 200                         }
 201
 202                         child->exit_code = data;
 203
 204                         /* TODO: make sure any pending breakpoint is killed */
 205                         wake_up_process(child);
 206                         ret = 0;
 207
 208                         break;
 209
 210                 /* Make the child exit by sending it a sigkill. */
 211                 case PTRACE_KILL:
 212                         ret = 0;
 213
 214                         if (child->exit_state == EXIT_ZOMBIE)
 215                                 break;
 216
 217                         child->exit_code = SIGKILL;
 218
 219                         /* Deconfigure single-step and h/w bp. */
 220                         ptrace_disable(child);
 221
 222                         /* TODO: make sure any pending breakpoint is killed */
 223                         wake_up_process(child);
 224                         break;
 225
 226                 /* Set the trap flag. */
 227                 case PTRACE_SINGLESTEP: {
 228                         unsigned long tmp;
 229                         ret = -EIO;
 230
 231                         /* Set up SPC if not set already (in which case we have
 232                            no other choice but to trust it). */
 233                         if (!get_reg(child, PT_SPC)) {
 234                                 /* In case we're stopped in a delay slot. */
 235                                 tmp = get_reg(child, PT_ERP) & ~1;
 236                                 put_reg(child, PT_SPC, tmp);
 237                         }
 238                         tmp = get_reg(child, PT_CCS) | SBIT_USER;
 239                         put_reg(child, PT_CCS, tmp);
 240
 241                         if (!valid_signal(data))
 242                                 break;
 243
 244                         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 245
 246                         /* TODO: set some clever breakpoint mechanism... */
 247
 248                         child->exit_code = data;
 249                         wake_up_process(child);
 250                         ret = 0;
 251                         break;
 252
 253                 }
 254                 case PTRACE_DETACH:
 255                         ret = ptrace_detach(child, data);
 256                         break;
 257
 258                 /* Get all GP registers from the child. */
 259                 case PTRACE_GETREGS: {
 260                         int i;
 261                         unsigned long tmp;
 262
 263                         for (i = 0; i <= PT_MAX; i++) {
 264                                 tmp = get_reg(child, i);
 265
 266                                 if (put_user(tmp, datap)) {
 267                                         ret = -EFAULT;
 268                                         goto out_tsk;
 269                                 }
 270
 271                                 datap++;
 272                         }
 273
 274                         ret = 0;
 275                         break;
 276                 }
 277
 278                 /* Set all GP registers in the child. */
 279                 case PTRACE_SETREGS: {
 280                         int i;
 281                         unsigned long tmp;
 282
 283                         for (i = 0; i <= PT_MAX; i++) {
 284                                 if (get_user(tmp, datap)) {
 285                                         ret = -EFAULT;
 286                                         goto out_tsk;
 287                                 }
 288
 289                                 if (i == PT_CCS) {
 290                                         tmp &= CCS_MASK;
 291                                         tmp |= get_reg(child, PT_CCS) & ~CCS_MASK;
 292                                 }
 293
 294                                 put_reg(child, i, tmp);
 295                                 datap++;
 296                         }
 297
 298                         ret = 0;
 299                         break;
 300                 }
 301
 302                 default:
 303                         ret = ptrace_request(child, request, addr, data);
 304                         break;
 305         }
 306
 307         return ret;
 308 }
 309
 310 void do_syscall_trace(void)
 311 {
 312         if (!test_thread_flag(TIF_SYSCALL_TRACE))
 313                 return;
 314
 315         if (!(current->ptrace & PT_PTRACED))
 316                 return;
 317
 318         /* the 0x80 provides a way for the tracing parent to distinguish
 319            between a syscall stop and SIGTRAP delivery */
 320         ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
 321                                  ? 0x80 : 0));
 322
 323         /*
 324          * This isn't the same as continuing with a signal, but it will do for
 325          * normal use.
 326          */
 327         if (current->exit_code) {
 328                 send_sig(current->exit_code, current, 1);
 329                 current->exit_code = 0;
 330         }
 331 }
 332
 333 /* Returns the size of an instruction that has a delay slot. */
 334
 335 static int insn_size(struct task_struct *child, unsigned long pc)
 336 {
 337   unsigned long opcode;
 338   int copied;
 339   int opsize = 0;
 340
 341   /* Read the opcode at pc (do what PTRACE_PEEKTEXT would do). */
 342   copied = access_process_vm(child, pc, &opcode, sizeof(opcode), 0);
 343   if (copied != sizeof(opcode))
 344     return 0;
 345
 346   switch ((opcode & 0x0f00) >> 8) {
 347   case 0x0:
 348   case 0x9:
 349   case 0xb:
 350           opsize = 2;
 351           break;
 352   case 0xe:
 353   case 0xf:
 354           opsize = 6;
 355           break;
 356   case 0xd:
 357           /* Could be 4 or 6; check more bits. */
 358           if ((opcode & 0xff) == 0xff)
 359                   opsize = 4;
 360           else
 361                   opsize = 6;
 362           break;
 363   default:
 364           panic("ERROR: Couldn't find size of opcode 0x%lx at 0x%lx\n",
 365                 opcode, pc);
 366   }
 367
 368   return opsize;
 369 }
 370
 371 static unsigned long get_pseudo_pc(struct task_struct *child)
 372 {
 373         /* Default value for PC is ERP. */
 374         unsigned long pc = get_reg(child, PT_ERP);
 375
 376         if (pc & 0x1) {
 377                 unsigned long spc = get_reg(child, PT_SPC);
 378                 /* Delay slot bit set. Report as stopped on proper
 379                    instruction. */
 380                 if (spc) {
 381                         /* Rely on SPC if set. FIXME: We might want to check
 382                            that EXS indicates we stopped due to a single-step
 383                            exception. */
 384                         pc = spc;
 385                 } else {
 386                         /* Calculate the PC from the size of the instruction
 387                            that the delay slot we're in belongs to. */
 388                         pc += insn_size(child, pc & ~1) - 1;
 389                 }
 390         }
 391         return pc;
 392 }
 393
 394 static long bp_owner = 0;
 395
 396 /* Reachable from exit_thread in signal.c, so not static. */
 397 void deconfigure_bp(long pid)
 398 {
 399         int bp;
 400
 401         /* Only deconfigure if the pid is the owner. */
 402         if (bp_owner != pid)
 403                 return;
 404
 405         for (bp = 0; bp < 6; bp++) {
 406                 unsigned long tmp;
 407                 /* Deconfigure start and end address (also gets rid of ownership). */
 408                 put_debugreg(pid, PT_BP + 3 + (bp * 2), 0);
 409                 put_debugreg(pid, PT_BP + 4 + (bp * 2), 0);
 410
 411                 /* Deconfigure relevant bits in control register. */
 412                 tmp = get_debugreg(pid, PT_BP_CTRL) & ~(3 << (2 + (bp * 4)));
 413                 put_debugreg(pid, PT_BP_CTRL, tmp);
 414         }
 415         /* No owner now. */
 416         bp_owner = 0;
 417 }
 418
 419 static int put_debugreg(long pid, unsigned int regno, long data)
 420 {
 421         int ret = 0;
 422         register int old_srs;
 423
 424 #ifdef CONFIG_ETRAX_KGDB
 425         /* Ignore write, but pretend it was ok if value is 0
 426            (we don't want POKEUSR/SETREGS failing unnessecarily). */
 427         return (data == 0) ? ret : -1;
 428 #endif
 429
 430         /* Simple owner management. */
 431         if (!bp_owner)
 432                 bp_owner = pid;
 433         else if (bp_owner != pid) {
 434                 /* Ignore write, but pretend it was ok if value is 0
 435                    (we don't want POKEUSR/SETREGS failing unnessecarily). */
 436                 return (data == 0) ? ret : -1;
 437         }
 438
 439         /* Remember old SRS. */
 440         SPEC_REG_RD(SPEC_REG_SRS, old_srs);
 441         /* Switch to BP bank. */
 442         SUPP_BANK_SEL(BANK_BP);
 443
 444         switch (regno - PT_BP) {
 445         case 0:
 446                 SUPP_REG_WR(0, data); break;
 447         case 1:
 448         case 2:
 449                 if (data)
 450                         ret = -1;
 451                 break;
 452         case 3:
 453                 SUPP_REG_WR(3, data); break;
 454         case 4:
 455                 SUPP_REG_WR(4, data); break;
 456         case 5:
 457                 SUPP_REG_WR(5, data); break;
 458         case 6:
 459                 SUPP_REG_WR(6, data); break;
 460         case 7:
 461                 SUPP_REG_WR(7, data); break;
 462         case 8:
 463                 SUPP_REG_WR(8, data); break;
 464         case 9:
 465                 SUPP_REG_WR(9, data); break;
 466         case 10:
 467                 SUPP_REG_WR(10, data); break;
 468         case 11:
 469                 SUPP_REG_WR(11, data); break;
 470         case 12:
 471                 SUPP_REG_WR(12, data); break;
 472         case 13:
 473                 SUPP_REG_WR(13, data); break;
 474         case 14:
 475                 SUPP_REG_WR(14, data); break;
 476         default:
 477                 ret = -1;
 478                 break;
 479         }
 480
 481         /* Restore SRS. */
 482         SPEC_REG_WR(SPEC_REG_SRS, old_srs);
 483         /* Just for show. */
 484         NOP();
 485         NOP();
 486         NOP();
 487
 488         return ret;
 489 }
 490
 491 static long get_debugreg(long pid, unsigned int regno)
 492 {
 493         register int old_srs;
 494         register long data;
 495
 496         if (pid != bp_owner) {
 497                 return 0;
 498         }
 499
 500         /* Remember old SRS. */
 501         SPEC_REG_RD(SPEC_REG_SRS, old_srs);
 502         /* Switch to BP bank. */
 503         SUPP_BANK_SEL(BANK_BP);
 504
 505         switch (regno - PT_BP) {
 506         case 0:
 507                 SUPP_REG_RD(0, data); break;
 508         case 1:
 509         case 2:
 510                 /* error return value? */
 511                 data = 0;
 512                 break;
 513         case 3:
 514                 SUPP_REG_RD(3, data); break;
 515         case 4:
 516                 SUPP_REG_RD(4, data); break;
 517         case 5:
 518                 SUPP_REG_RD(5, data); break;
 519         case 6:
 520                 SUPP_REG_RD(6, data); break;
 521         case 7:
 522                 SUPP_REG_RD(7, data); break;
 523         case 8:
 524                 SUPP_REG_RD(8, data); break;
 525         case 9:
 526                 SUPP_REG_RD(9, data); break;
 527         case 10:
 528                 SUPP_REG_RD(10, data); break;
 529         case 11:
 530                 SUPP_REG_RD(11, data); break;
 531         case 12:
 532                 SUPP_REG_RD(12, data); break;
 533         case 13:
 534                 SUPP_REG_RD(13, data); break;
 535         case 14:
 536                 SUPP_REG_RD(14, data); break;
 537         default:
 538                 /* error return value? */
 539                 data = 0;
 540         }
 541
 542         /* Restore SRS. */
 543         SPEC_REG_WR(SPEC_REG_SRS, old_srs);
 544         /* Just for show. */
 545         NOP();
 546         NOP();
 547         NOP();
 548
 549         return data;
 550 }