1 /* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * Copyright (C) 1992 Ross Biro 7 * Copyright (C) Linus Torvalds 8 * Copyright (C) 1994, 95, 96, 97, 98, 2000 Ralf Baechle 9 * Copyright (C) 1996 David S. Miller 10 * Kevin D. Kissell, kevink@mips.com and Carsten Langgaard, carstenl@mips.com 11 * Copyright (C) 1999 MIPS Technologies, Inc. 12 * Copyright (C) 2000 Ulf Carlsson 13 * 14 * At this time Linux/MIPS64 only supports syscall tracing, even for 32-bit 15 * binaries. 16 */ 17 #include <linux/compiler.h> 18 #include <linux/context_tracking.h> 19 #include <linux/elf.h> 20 #include <linux/kernel.h> 21 #include <linux/sched.h> 22 #include <linux/mm.h> 23 #include <linux/errno.h> 24 #include <linux/ptrace.h> 25 #include <linux/regset.h> 26 #include <linux/smp.h> 27 #include <linux/security.h> 28 #include <linux/stddef.h> 29 #include <linux/tracehook.h> 30 #include <linux/audit.h> 31 #include <linux/seccomp.h> 32 #include <linux/ftrace.h> 33 34 #include <asm/byteorder.h> 35 #include <asm/cpu.h> 36 #include <asm/cpu-info.h> 37 #include <asm/dsp.h> 38 #include <asm/fpu.h> 39 #include <asm/mipsregs.h> 40 #include <asm/mipsmtregs.h> 41 #include <asm/pgtable.h> 42 #include <asm/page.h> 43 #include <asm/syscall.h> 44 #include <asm/uaccess.h> 45 #include <asm/bootinfo.h> 46 #include <asm/reg.h> 47 48 #define CREATE_TRACE_POINTS 49 #include <trace/events/syscalls.h> 50 51 static void init_fp_ctx(struct task_struct *target) 52 { 53 /* If FP has been used then the target already has context */ 54 if (tsk_used_math(target)) 55 return; 56 57 /* Begin with data registers set to all 1s... */ 58 memset(&target->thread.fpu.fpr, ~0, sizeof(target->thread.fpu.fpr)); 59 60 /* ...and FCSR zeroed */ 61 target->thread.fpu.fcr31 = 0; 62 63 /* 64 * Record that the target has "used" math, such that the context 65 * just initialised, and any modifications made by the caller, 66 * aren't discarded. 67 */ 68 set_stopped_child_used_math(target); 69 } 70 71 /* 72 * Called by kernel/ptrace.c when detaching.. 73 * 74 * Make sure single step bits etc are not set. 75 */ 76 void ptrace_disable(struct task_struct *child) 77 { 78 /* Don't load the watchpoint registers for the ex-child. */ 79 clear_tsk_thread_flag(child, TIF_LOAD_WATCH); 80 } 81 82 /* 83 * Read a general register set. We always use the 64-bit format, even 84 * for 32-bit kernels and for 32-bit processes on a 64-bit kernel. 85 * Registers are sign extended to fill the available space. 86 */ 87 int ptrace_getregs(struct task_struct *child, struct user_pt_regs __user *data) 88 { 89 struct pt_regs *regs; 90 int i; 91 92 if (!access_ok(VERIFY_WRITE, data, 38 * 8)) 93 return -EIO; 94 95 regs = task_pt_regs(child); 96 97 for (i = 0; i < 32; i++) 98 __put_user((long)regs->regs[i], (__s64 __user *)&data->regs[i]); 99 __put_user((long)regs->lo, (__s64 __user *)&data->lo); 100 __put_user((long)regs->hi, (__s64 __user *)&data->hi); 101 __put_user((long)regs->cp0_epc, (__s64 __user *)&data->cp0_epc); 102 __put_user((long)regs->cp0_badvaddr, (__s64 __user *)&data->cp0_badvaddr); 103 __put_user((long)regs->cp0_status, (__s64 __user *)&data->cp0_status); 104 __put_user((long)regs->cp0_cause, (__s64 __user *)&data->cp0_cause); 105 106 return 0; 107 } 108 109 /* 110 * Write a general register set. As for PTRACE_GETREGS, we always use 111 * the 64-bit format. On a 32-bit kernel only the lower order half 112 * (according to endianness) will be used. 113 */ 114 int ptrace_setregs(struct task_struct *child, struct user_pt_regs __user *data) 115 { 116 struct pt_regs *regs; 117 int i; 118 119 if (!access_ok(VERIFY_READ, data, 38 * 8)) 120 return -EIO; 121 122 regs = task_pt_regs(child); 123 124 for (i = 0; i < 32; i++) 125 __get_user(regs->regs[i], (__s64 __user *)&data->regs[i]); 126 __get_user(regs->lo, (__s64 __user *)&data->lo); 127 __get_user(regs->hi, (__s64 __user *)&data->hi); 128 __get_user(regs->cp0_epc, (__s64 __user *)&data->cp0_epc); 129 130 /* badvaddr, status, and cause may not be written. */ 131 132 return 0; 133 } 134 135 int ptrace_getfpregs(struct task_struct *child, __u32 __user *data) 136 { 137 int i; 138 139 if (!access_ok(VERIFY_WRITE, data, 33 * 8)) 140 return -EIO; 141 142 if (tsk_used_math(child)) { 143 union fpureg *fregs = get_fpu_regs(child); 144 for (i = 0; i < 32; i++) 145 __put_user(get_fpr64(&fregs[i], 0), 146 i + (__u64 __user *)data); 147 } else { 148 for (i = 0; i < 32; i++) 149 __put_user((__u64) -1, i + (__u64 __user *) data); 150 } 151 152 __put_user(child->thread.fpu.fcr31, data + 64); 153 __put_user(boot_cpu_data.fpu_id, data + 65); 154 155 return 0; 156 } 157 158 int ptrace_setfpregs(struct task_struct *child, __u32 __user *data) 159 { 160 union fpureg *fregs; 161 u64 fpr_val; 162 u32 fcr31; 163 u32 value; 164 u32 mask; 165 int i; 166 167 if (!access_ok(VERIFY_READ, data, 33 * 8)) 168 return -EIO; 169 170 init_fp_ctx(child); 171 fregs = get_fpu_regs(child); 172 173 for (i = 0; i < 32; i++) { 174 __get_user(fpr_val, i + (__u64 __user *)data); 175 set_fpr64(&fregs[i], 0, fpr_val); 176 } 177 178 __get_user(value, data + 64); 179 fcr31 = child->thread.fpu.fcr31; 180 mask = boot_cpu_data.fpu_msk31; 181 child->thread.fpu.fcr31 = (value & ~mask) | (fcr31 & mask); 182 183 /* FIR may not be written. */ 184 185 return 0; 186 } 187 188 int ptrace_get_watch_regs(struct task_struct *child, 189 struct pt_watch_regs __user *addr) 190 { 191 enum pt_watch_style style; 192 int i; 193 194 if (!cpu_has_watch || boot_cpu_data.watch_reg_use_cnt == 0) 195 return -EIO; 196 if (!access_ok(VERIFY_WRITE, addr, sizeof(struct pt_watch_regs))) 197 return -EIO; 198 199 #ifdef CONFIG_32BIT 200 style = pt_watch_style_mips32; 201 #define WATCH_STYLE mips32 202 #else 203 style = pt_watch_style_mips64; 204 #define WATCH_STYLE mips64 205 #endif 206 207 __put_user(style, &addr->style); 208 __put_user(boot_cpu_data.watch_reg_use_cnt, 209 &addr->WATCH_STYLE.num_valid); 210 for (i = 0; i < boot_cpu_data.watch_reg_use_cnt; i++) { 211 __put_user(child->thread.watch.mips3264.watchlo[i], 212 &addr->WATCH_STYLE.watchlo[i]); 213 __put_user(child->thread.watch.mips3264.watchhi[i] & 0xfff, 214 &addr->WATCH_STYLE.watchhi[i]); 215 __put_user(boot_cpu_data.watch_reg_masks[i], 216 &addr->WATCH_STYLE.watch_masks[i]); 217 } 218 for (; i < 8; i++) { 219 __put_user(0, &addr->WATCH_STYLE.watchlo[i]); 220 __put_user(0, &addr->WATCH_STYLE.watchhi[i]); 221 __put_user(0, &addr->WATCH_STYLE.watch_masks[i]); 222 } 223 224 return 0; 225 } 226 227 int ptrace_set_watch_regs(struct task_struct *child, 228 struct pt_watch_regs __user *addr) 229 { 230 int i; 231 int watch_active = 0; 232 unsigned long lt[NUM_WATCH_REGS]; 233 u16 ht[NUM_WATCH_REGS]; 234 235 if (!cpu_has_watch || boot_cpu_data.watch_reg_use_cnt == 0) 236 return -EIO; 237 if (!access_ok(VERIFY_READ, addr, sizeof(struct pt_watch_regs))) 238 return -EIO; 239 /* Check the values. */ 240 for (i = 0; i < boot_cpu_data.watch_reg_use_cnt; i++) { 241 __get_user(lt[i], &addr->WATCH_STYLE.watchlo[i]); 242 #ifdef CONFIG_32BIT 243 if (lt[i] & __UA_LIMIT) 244 return -EINVAL; 245 #else 246 if (test_tsk_thread_flag(child, TIF_32BIT_ADDR)) { 247 if (lt[i] & 0xffffffff80000000UL) 248 return -EINVAL; 249 } else { 250 if (lt[i] & __UA_LIMIT) 251 return -EINVAL; 252 } 253 #endif 254 __get_user(ht[i], &addr->WATCH_STYLE.watchhi[i]); 255 if (ht[i] & ~0xff8) 256 return -EINVAL; 257 } 258 /* Install them. */ 259 for (i = 0; i < boot_cpu_data.watch_reg_use_cnt; i++) { 260 if (lt[i] & 7) 261 watch_active = 1; 262 child->thread.watch.mips3264.watchlo[i] = lt[i]; 263 /* Set the G bit. */ 264 child->thread.watch.mips3264.watchhi[i] = ht[i]; 265 } 266 267 if (watch_active) 268 set_tsk_thread_flag(child, TIF_LOAD_WATCH); 269 else 270 clear_tsk_thread_flag(child, TIF_LOAD_WATCH); 271 272 return 0; 273 } 274 275 /* regset get/set implementations */ 276 277 #if defined(CONFIG_32BIT) || defined(CONFIG_MIPS32_O32) 278 279 static int gpr32_get(struct task_struct *target, 280 const struct user_regset *regset, 281 unsigned int pos, unsigned int count, 282 void *kbuf, void __user *ubuf) 283 { 284 struct pt_regs *regs = task_pt_regs(target); 285 u32 uregs[ELF_NGREG] = {}; 286 unsigned i; 287 288 for (i = MIPS32_EF_R1; i <= MIPS32_EF_R31; i++) { 289 /* k0/k1 are copied as zero. */ 290 if (i == MIPS32_EF_R26 || i == MIPS32_EF_R27) 291 continue; 292 293 uregs[i] = regs->regs[i - MIPS32_EF_R0]; 294 } 295 296 uregs[MIPS32_EF_LO] = regs->lo; 297 uregs[MIPS32_EF_HI] = regs->hi; 298 uregs[MIPS32_EF_CP0_EPC] = regs->cp0_epc; 299 uregs[MIPS32_EF_CP0_BADVADDR] = regs->cp0_badvaddr; 300 uregs[MIPS32_EF_CP0_STATUS] = regs->cp0_status; 301 uregs[MIPS32_EF_CP0_CAUSE] = regs->cp0_cause; 302 303 return user_regset_copyout(&pos, &count, &kbuf, &ubuf, uregs, 0, 304 sizeof(uregs)); 305 } 306 307 static int gpr32_set(struct task_struct *target, 308 const struct user_regset *regset, 309 unsigned int pos, unsigned int count, 310 const void *kbuf, const void __user *ubuf) 311 { 312 struct pt_regs *regs = task_pt_regs(target); 313 u32 uregs[ELF_NGREG]; 314 unsigned start, num_regs, i; 315 int err; 316 317 start = pos / sizeof(u32); 318 num_regs = count / sizeof(u32); 319 320 if (start + num_regs > ELF_NGREG) 321 return -EIO; 322 323 err = user_regset_copyin(&pos, &count, &kbuf, &ubuf, uregs, 0, 324 sizeof(uregs)); 325 if (err) 326 return err; 327 328 for (i = start; i < num_regs; i++) { 329 /* 330 * Cast all values to signed here so that if this is a 64-bit 331 * kernel, the supplied 32-bit values will be sign extended. 332 */ 333 switch (i) { 334 case MIPS32_EF_R1 ... MIPS32_EF_R25: 335 /* k0/k1 are ignored. */ 336 case MIPS32_EF_R28 ... MIPS32_EF_R31: 337 regs->regs[i - MIPS32_EF_R0] = (s32)uregs[i]; 338 break; 339 case MIPS32_EF_LO: 340 regs->lo = (s32)uregs[i]; 341 break; 342 case MIPS32_EF_HI: 343 regs->hi = (s32)uregs[i]; 344 break; 345 case MIPS32_EF_CP0_EPC: 346 regs->cp0_epc = (s32)uregs[i]; 347 break; 348 } 349 } 350 351 return 0; 352 } 353 354 #endif /* CONFIG_32BIT || CONFIG_MIPS32_O32 */ 355 356 #ifdef CONFIG_64BIT 357 358 static int gpr64_get(struct task_struct *target, 359 const struct user_regset *regset, 360 unsigned int pos, unsigned int count, 361 void *kbuf, void __user *ubuf) 362 { 363 struct pt_regs *regs = task_pt_regs(target); 364 u64 uregs[ELF_NGREG] = {}; 365 unsigned i; 366 367 for (i = MIPS64_EF_R1; i <= MIPS64_EF_R31; i++) { 368 /* k0/k1 are copied as zero. */ 369 if (i == MIPS64_EF_R26 || i == MIPS64_EF_R27) 370 continue; 371 372 uregs[i] = regs->regs[i - MIPS64_EF_R0]; 373 } 374 375 uregs[MIPS64_EF_LO] = regs->lo; 376 uregs[MIPS64_EF_HI] = regs->hi; 377 uregs[MIPS64_EF_CP0_EPC] = regs->cp0_epc; 378 uregs[MIPS64_EF_CP0_BADVADDR] = regs->cp0_badvaddr; 379 uregs[MIPS64_EF_CP0_STATUS] = regs->cp0_status; 380 uregs[MIPS64_EF_CP0_CAUSE] = regs->cp0_cause; 381 382 return user_regset_copyout(&pos, &count, &kbuf, &ubuf, uregs, 0, 383 sizeof(uregs)); 384 } 385 386 static int gpr64_set(struct task_struct *target, 387 const struct user_regset *regset, 388 unsigned int pos, unsigned int count, 389 const void *kbuf, const void __user *ubuf) 390 { 391 struct pt_regs *regs = task_pt_regs(target); 392 u64 uregs[ELF_NGREG]; 393 unsigned start, num_regs, i; 394 int err; 395 396 start = pos / sizeof(u64); 397 num_regs = count / sizeof(u64); 398 399 if (start + num_regs > ELF_NGREG) 400 return -EIO; 401 402 err = user_regset_copyin(&pos, &count, &kbuf, &ubuf, uregs, 0, 403 sizeof(uregs)); 404 if (err) 405 return err; 406 407 for (i = start; i < num_regs; i++) { 408 switch (i) { 409 case MIPS64_EF_R1 ... MIPS64_EF_R25: 410 /* k0/k1 are ignored. */ 411 case MIPS64_EF_R28 ... MIPS64_EF_R31: 412 regs->regs[i - MIPS64_EF_R0] = uregs[i]; 413 break; 414 case MIPS64_EF_LO: 415 regs->lo = uregs[i]; 416 break; 417 case MIPS64_EF_HI: 418 regs->hi = uregs[i]; 419 break; 420 case MIPS64_EF_CP0_EPC: 421 regs->cp0_epc = uregs[i]; 422 break; 423 } 424 } 425 426 return 0; 427 } 428 429 #endif /* CONFIG_64BIT */ 430 431 static int fpr_get(struct task_struct *target, 432 const struct user_regset *regset, 433 unsigned int pos, unsigned int count, 434 void *kbuf, void __user *ubuf) 435 { 436 unsigned i; 437 int err; 438 u64 fpr_val; 439 440 /* XXX fcr31 */ 441 442 if (sizeof(target->thread.fpu.fpr[i]) == sizeof(elf_fpreg_t)) 443 return user_regset_copyout(&pos, &count, &kbuf, &ubuf, 444 &target->thread.fpu, 445 0, sizeof(elf_fpregset_t)); 446 447 for (i = 0; i < NUM_FPU_REGS; i++) { 448 fpr_val = get_fpr64(&target->thread.fpu.fpr[i], 0); 449 err = user_regset_copyout(&pos, &count, &kbuf, &ubuf, 450 &fpr_val, i * sizeof(elf_fpreg_t), 451 (i + 1) * sizeof(elf_fpreg_t)); 452 if (err) 453 return err; 454 } 455 456 return 0; 457 } 458 459 static int fpr_set(struct task_struct *target, 460 const struct user_regset *regset, 461 unsigned int pos, unsigned int count, 462 const void *kbuf, const void __user *ubuf) 463 { 464 unsigned i; 465 int err; 466 u64 fpr_val; 467 468 /* XXX fcr31 */ 469 470 init_fp_ctx(target); 471 472 if (sizeof(target->thread.fpu.fpr[i]) == sizeof(elf_fpreg_t)) 473 return user_regset_copyin(&pos, &count, &kbuf, &ubuf, 474 &target->thread.fpu, 475 0, sizeof(elf_fpregset_t)); 476 477 for (i = 0; i < NUM_FPU_REGS; i++) { 478 err = user_regset_copyin(&pos, &count, &kbuf, &ubuf, 479 &fpr_val, i * sizeof(elf_fpreg_t), 480 (i + 1) * sizeof(elf_fpreg_t)); 481 if (err) 482 return err; 483 set_fpr64(&target->thread.fpu.fpr[i], 0, fpr_val); 484 } 485 486 return 0; 487 } 488 489 enum mips_regset { 490 REGSET_GPR, 491 REGSET_FPR, 492 }; 493 494 struct pt_regs_offset { 495 const char *name; 496 int offset; 497 }; 498 499 #define REG_OFFSET_NAME(reg, r) { \ 500 .name = #reg, \ 501 .offset = offsetof(struct pt_regs, r) \ 502 } 503 504 #define REG_OFFSET_END { \ 505 .name = NULL, \ 506 .offset = 0 \ 507 } 508 509 static const struct pt_regs_offset regoffset_table[] = { 510 REG_OFFSET_NAME(r0, regs[0]), 511 REG_OFFSET_NAME(r1, regs[1]), 512 REG_OFFSET_NAME(r2, regs[2]), 513 REG_OFFSET_NAME(r3, regs[3]), 514 REG_OFFSET_NAME(r4, regs[4]), 515 REG_OFFSET_NAME(r5, regs[5]), 516 REG_OFFSET_NAME(r6, regs[6]), 517 REG_OFFSET_NAME(r7, regs[7]), 518 REG_OFFSET_NAME(r8, regs[8]), 519 REG_OFFSET_NAME(r9, regs[9]), 520 REG_OFFSET_NAME(r10, regs[10]), 521 REG_OFFSET_NAME(r11, regs[11]), 522 REG_OFFSET_NAME(r12, regs[12]), 523 REG_OFFSET_NAME(r13, regs[13]), 524 REG_OFFSET_NAME(r14, regs[14]), 525 REG_OFFSET_NAME(r15, regs[15]), 526 REG_OFFSET_NAME(r16, regs[16]), 527 REG_OFFSET_NAME(r17, regs[17]), 528 REG_OFFSET_NAME(r18, regs[18]), 529 REG_OFFSET_NAME(r19, regs[19]), 530 REG_OFFSET_NAME(r20, regs[20]), 531 REG_OFFSET_NAME(r21, regs[21]), 532 REG_OFFSET_NAME(r22, regs[22]), 533 REG_OFFSET_NAME(r23, regs[23]), 534 REG_OFFSET_NAME(r24, regs[24]), 535 REG_OFFSET_NAME(r25, regs[25]), 536 REG_OFFSET_NAME(r26, regs[26]), 537 REG_OFFSET_NAME(r27, regs[27]), 538 REG_OFFSET_NAME(r28, regs[28]), 539 REG_OFFSET_NAME(r29, regs[29]), 540 REG_OFFSET_NAME(r30, regs[30]), 541 REG_OFFSET_NAME(r31, regs[31]), 542 REG_OFFSET_NAME(c0_status, cp0_status), 543 REG_OFFSET_NAME(hi, hi), 544 REG_OFFSET_NAME(lo, lo), 545 #ifdef CONFIG_CPU_HAS_SMARTMIPS 546 REG_OFFSET_NAME(acx, acx), 547 #endif 548 REG_OFFSET_NAME(c0_badvaddr, cp0_badvaddr), 549 REG_OFFSET_NAME(c0_cause, cp0_cause), 550 REG_OFFSET_NAME(c0_epc, cp0_epc), 551 #ifdef CONFIG_CPU_CAVIUM_OCTEON 552 REG_OFFSET_NAME(mpl0, mpl[0]), 553 REG_OFFSET_NAME(mpl1, mpl[1]), 554 REG_OFFSET_NAME(mpl2, mpl[2]), 555 REG_OFFSET_NAME(mtp0, mtp[0]), 556 REG_OFFSET_NAME(mtp1, mtp[1]), 557 REG_OFFSET_NAME(mtp2, mtp[2]), 558 #endif 559 REG_OFFSET_END, 560 }; 561 562 /** 563 * regs_query_register_offset() - query register offset from its name 564 * @name: the name of a register 565 * 566 * regs_query_register_offset() returns the offset of a register in struct 567 * pt_regs from its name. If the name is invalid, this returns -EINVAL; 568 */ 569 int regs_query_register_offset(const char *name) 570 { 571 const struct pt_regs_offset *roff; 572 for (roff = regoffset_table; roff->name != NULL; roff++) 573 if (!strcmp(roff->name, name)) 574 return roff->offset; 575 return -EINVAL; 576 } 577 578 #if defined(CONFIG_32BIT) || defined(CONFIG_MIPS32_O32) 579 580 static const struct user_regset mips_regsets[] = { 581 [REGSET_GPR] = { 582 .core_note_type = NT_PRSTATUS, 583 .n = ELF_NGREG, 584 .size = sizeof(unsigned int), 585 .align = sizeof(unsigned int), 586 .get = gpr32_get, 587 .set = gpr32_set, 588 }, 589 [REGSET_FPR] = { 590 .core_note_type = NT_PRFPREG, 591 .n = ELF_NFPREG, 592 .size = sizeof(elf_fpreg_t), 593 .align = sizeof(elf_fpreg_t), 594 .get = fpr_get, 595 .set = fpr_set, 596 }, 597 }; 598 599 static const struct user_regset_view user_mips_view = { 600 .name = "mips", 601 .e_machine = ELF_ARCH, 602 .ei_osabi = ELF_OSABI, 603 .regsets = mips_regsets, 604 .n = ARRAY_SIZE(mips_regsets), 605 }; 606 607 #endif /* CONFIG_32BIT || CONFIG_MIPS32_O32 */ 608 609 #ifdef CONFIG_64BIT 610 611 static const struct user_regset mips64_regsets[] = { 612 [REGSET_GPR] = { 613 .core_note_type = NT_PRSTATUS, 614 .n = ELF_NGREG, 615 .size = sizeof(unsigned long), 616 .align = sizeof(unsigned long), 617 .get = gpr64_get, 618 .set = gpr64_set, 619 }, 620 [REGSET_FPR] = { 621 .core_note_type = NT_PRFPREG, 622 .n = ELF_NFPREG, 623 .size = sizeof(elf_fpreg_t), 624 .align = sizeof(elf_fpreg_t), 625 .get = fpr_get, 626 .set = fpr_set, 627 }, 628 }; 629 630 static const struct user_regset_view user_mips64_view = { 631 .name = "mips64", 632 .e_machine = ELF_ARCH, 633 .ei_osabi = ELF_OSABI, 634 .regsets = mips64_regsets, 635 .n = ARRAY_SIZE(mips64_regsets), 636 }; 637 638 #endif /* CONFIG_64BIT */ 639 640 const struct user_regset_view *task_user_regset_view(struct task_struct *task) 641 { 642 #ifdef CONFIG_32BIT 643 return &user_mips_view; 644 #else 645 #ifdef CONFIG_MIPS32_O32 646 if (test_tsk_thread_flag(task, TIF_32BIT_REGS)) 647 return &user_mips_view; 648 #endif 649 return &user_mips64_view; 650 #endif 651 } 652 653 long arch_ptrace(struct task_struct *child, long request, 654 unsigned long addr, unsigned long data) 655 { 656 int ret; 657 void __user *addrp = (void __user *) addr; 658 void __user *datavp = (void __user *) data; 659 unsigned long __user *datalp = (void __user *) data; 660 661 switch (request) { 662 /* when I and D space are separate, these will need to be fixed. */ 663 case PTRACE_PEEKTEXT: /* read word at location addr. */ 664 case PTRACE_PEEKDATA: 665 ret = generic_ptrace_peekdata(child, addr, data); 666 break; 667 668 /* Read the word at location addr in the USER area. */ 669 case PTRACE_PEEKUSR: { 670 struct pt_regs *regs; 671 union fpureg *fregs; 672 unsigned long tmp = 0; 673 674 regs = task_pt_regs(child); 675 ret = 0; /* Default return value. */ 676 677 switch (addr) { 678 case 0 ... 31: 679 tmp = regs->regs[addr]; 680 break; 681 case FPR_BASE ... FPR_BASE + 31: 682 if (!tsk_used_math(child)) { 683 /* FP not yet used */ 684 tmp = -1; 685 break; 686 } 687 fregs = get_fpu_regs(child); 688 689 #ifdef CONFIG_32BIT 690 if (test_thread_flag(TIF_32BIT_FPREGS)) { 691 /* 692 * The odd registers are actually the high 693 * order bits of the values stored in the even 694 * registers - unless we're using r2k_switch.S. 695 */ 696 tmp = get_fpr32(&fregs[(addr & ~1) - FPR_BASE], 697 addr & 1); 698 break; 699 } 700 #endif 701 tmp = get_fpr32(&fregs[addr - FPR_BASE], 0); 702 break; 703 case PC: 704 tmp = regs->cp0_epc; 705 break; 706 case CAUSE: 707 tmp = regs->cp0_cause; 708 break; 709 case BADVADDR: 710 tmp = regs->cp0_badvaddr; 711 break; 712 case MMHI: 713 tmp = regs->hi; 714 break; 715 case MMLO: 716 tmp = regs->lo; 717 break; 718 #ifdef CONFIG_CPU_HAS_SMARTMIPS 719 case ACX: 720 tmp = regs->acx; 721 break; 722 #endif 723 case FPC_CSR: 724 tmp = child->thread.fpu.fcr31; 725 break; 726 case FPC_EIR: 727 /* implementation / version register */ 728 tmp = boot_cpu_data.fpu_id; 729 break; 730 case DSP_BASE ... DSP_BASE + 5: { 731 dspreg_t *dregs; 732 733 if (!cpu_has_dsp) { 734 tmp = 0; 735 ret = -EIO; 736 goto out; 737 } 738 dregs = __get_dsp_regs(child); 739 tmp = (unsigned long) (dregs[addr - DSP_BASE]); 740 break; 741 } 742 case DSP_CONTROL: 743 if (!cpu_has_dsp) { 744 tmp = 0; 745 ret = -EIO; 746 goto out; 747 } 748 tmp = child->thread.dsp.dspcontrol; 749 break; 750 default: 751 tmp = 0; 752 ret = -EIO; 753 goto out; 754 } 755 ret = put_user(tmp, datalp); 756 break; 757 } 758 759 /* when I and D space are separate, this will have to be fixed. */ 760 case PTRACE_POKETEXT: /* write the word at location addr. */ 761 case PTRACE_POKEDATA: 762 ret = generic_ptrace_pokedata(child, addr, data); 763 break; 764 765 case PTRACE_POKEUSR: { 766 struct pt_regs *regs; 767 ret = 0; 768 regs = task_pt_regs(child); 769 770 switch (addr) { 771 case 0 ... 31: 772 regs->regs[addr] = data; 773 break; 774 case FPR_BASE ... FPR_BASE + 31: { 775 union fpureg *fregs = get_fpu_regs(child); 776 777 init_fp_ctx(child); 778 #ifdef CONFIG_32BIT 779 if (test_thread_flag(TIF_32BIT_FPREGS)) { 780 /* 781 * The odd registers are actually the high 782 * order bits of the values stored in the even 783 * registers - unless we're using r2k_switch.S. 784 */ 785 set_fpr32(&fregs[(addr & ~1) - FPR_BASE], 786 addr & 1, data); 787 break; 788 } 789 #endif 790 set_fpr64(&fregs[addr - FPR_BASE], 0, data); 791 break; 792 } 793 case PC: 794 regs->cp0_epc = data; 795 break; 796 case MMHI: 797 regs->hi = data; 798 break; 799 case MMLO: 800 regs->lo = data; 801 break; 802 #ifdef CONFIG_CPU_HAS_SMARTMIPS 803 case ACX: 804 regs->acx = data; 805 break; 806 #endif 807 case FPC_CSR: 808 child->thread.fpu.fcr31 = data & ~FPU_CSR_ALL_X; 809 break; 810 case DSP_BASE ... DSP_BASE + 5: { 811 dspreg_t *dregs; 812 813 if (!cpu_has_dsp) { 814 ret = -EIO; 815 break; 816 } 817 818 dregs = __get_dsp_regs(child); 819 dregs[addr - DSP_BASE] = data; 820 break; 821 } 822 case DSP_CONTROL: 823 if (!cpu_has_dsp) { 824 ret = -EIO; 825 break; 826 } 827 child->thread.dsp.dspcontrol = data; 828 break; 829 default: 830 /* The rest are not allowed. */ 831 ret = -EIO; 832 break; 833 } 834 break; 835 } 836 837 case PTRACE_GETREGS: 838 ret = ptrace_getregs(child, datavp); 839 break; 840 841 case PTRACE_SETREGS: 842 ret = ptrace_setregs(child, datavp); 843 break; 844 845 case PTRACE_GETFPREGS: 846 ret = ptrace_getfpregs(child, datavp); 847 break; 848 849 case PTRACE_SETFPREGS: 850 ret = ptrace_setfpregs(child, datavp); 851 break; 852 853 case PTRACE_GET_THREAD_AREA: 854 ret = put_user(task_thread_info(child)->tp_value, datalp); 855 break; 856 857 case PTRACE_GET_WATCH_REGS: 858 ret = ptrace_get_watch_regs(child, addrp); 859 break; 860 861 case PTRACE_SET_WATCH_REGS: 862 ret = ptrace_set_watch_regs(child, addrp); 863 break; 864 865 default: 866 ret = ptrace_request(child, request, addr, data); 867 break; 868 } 869 out: 870 return ret; 871 } 872 873 /* 874 * Notification of system call entry/exit 875 * - triggered by current->work.syscall_trace 876 */ 877 asmlinkage long syscall_trace_enter(struct pt_regs *regs, long syscall) 878 { 879 long ret = 0; 880 user_exit(); 881 882 current_thread_info()->syscall = syscall; 883 884 if (secure_computing() == -1) 885 return -1; 886 887 if (test_thread_flag(TIF_SYSCALL_TRACE) && 888 tracehook_report_syscall_entry(regs)) 889 ret = -1; 890 891 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT))) 892 trace_sys_enter(regs, regs->regs[2]); 893 894 audit_syscall_entry(syscall, regs->regs[4], regs->regs[5], 895 regs->regs[6], regs->regs[7]); 896 return syscall; 897 } 898 899 /* 900 * Notification of system call entry/exit 901 * - triggered by current->work.syscall_trace 902 */ 903 asmlinkage void syscall_trace_leave(struct pt_regs *regs) 904 { 905 /* 906 * We may come here right after calling schedule_user() 907 * or do_notify_resume(), in which case we can be in RCU 908 * user mode. 909 */ 910 user_exit(); 911 912 audit_syscall_exit(regs); 913 914 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT))) 915 trace_sys_exit(regs, regs->regs[2]); 916 917 if (test_thread_flag(TIF_SYSCALL_TRACE)) 918 tracehook_report_syscall_exit(regs, 0); 919 920 user_enter(); 921 } 922