1 /* By Ross Biro 1/23/92 */ 2 /* 3 * Pentium III FXSR, SSE support 4 * Gareth Hughes <gareth@valinux.com>, May 2000 5 */ 6 7 #include <linux/kernel.h> 8 #include <linux/sched.h> 9 #include <linux/mm.h> 10 #include <linux/smp.h> 11 #include <linux/errno.h> 12 #include <linux/slab.h> 13 #include <linux/ptrace.h> 14 #include <linux/regset.h> 15 #include <linux/tracehook.h> 16 #include <linux/user.h> 17 #include <linux/elf.h> 18 #include <linux/security.h> 19 #include <linux/audit.h> 20 #include <linux/seccomp.h> 21 #include <linux/signal.h> 22 #include <linux/perf_event.h> 23 #include <linux/hw_breakpoint.h> 24 #include <linux/rcupdate.h> 25 #include <linux/module.h> 26 #include <linux/context_tracking.h> 27 28 #include <asm/uaccess.h> 29 #include <asm/pgtable.h> 30 #include <asm/processor.h> 31 #include <asm/i387.h> 32 #include <asm/fpu-internal.h> 33 #include <asm/debugreg.h> 34 #include <asm/ldt.h> 35 #include <asm/desc.h> 36 #include <asm/prctl.h> 37 #include <asm/proto.h> 38 #include <asm/hw_breakpoint.h> 39 #include <asm/traps.h> 40 41 #include "tls.h" 42 43 #define CREATE_TRACE_POINTS 44 #include <trace/events/syscalls.h> 45 46 enum x86_regset { 47 REGSET_GENERAL, 48 REGSET_FP, 49 REGSET_XFP, 50 REGSET_IOPERM64 = REGSET_XFP, 51 REGSET_XSTATE, 52 REGSET_TLS, 53 REGSET_IOPERM32, 54 }; 55 56 struct pt_regs_offset { 57 const char *name; 58 int offset; 59 }; 60 61 #define REG_OFFSET_NAME(r) {.name = #r, .offset = offsetof(struct pt_regs, r)} 62 #define REG_OFFSET_END {.name = NULL, .offset = 0} 63 64 static const struct pt_regs_offset regoffset_table[] = { 65 #ifdef CONFIG_X86_64 66 REG_OFFSET_NAME(r15), 67 REG_OFFSET_NAME(r14), 68 REG_OFFSET_NAME(r13), 69 REG_OFFSET_NAME(r12), 70 REG_OFFSET_NAME(r11), 71 REG_OFFSET_NAME(r10), 72 REG_OFFSET_NAME(r9), 73 REG_OFFSET_NAME(r8), 74 #endif 75 REG_OFFSET_NAME(bx), 76 REG_OFFSET_NAME(cx), 77 REG_OFFSET_NAME(dx), 78 REG_OFFSET_NAME(si), 79 REG_OFFSET_NAME(di), 80 REG_OFFSET_NAME(bp), 81 REG_OFFSET_NAME(ax), 82 #ifdef CONFIG_X86_32 83 REG_OFFSET_NAME(ds), 84 REG_OFFSET_NAME(es), 85 REG_OFFSET_NAME(fs), 86 REG_OFFSET_NAME(gs), 87 #endif 88 REG_OFFSET_NAME(orig_ax), 89 REG_OFFSET_NAME(ip), 90 REG_OFFSET_NAME(cs), 91 REG_OFFSET_NAME(flags), 92 REG_OFFSET_NAME(sp), 93 REG_OFFSET_NAME(ss), 94 REG_OFFSET_END, 95 }; 96 97 /** 98 * regs_query_register_offset() - query register offset from its name 99 * @name: the name of a register 100 * 101 * regs_query_register_offset() returns the offset of a register in struct 102 * pt_regs from its name. If the name is invalid, this returns -EINVAL; 103 */ 104 int regs_query_register_offset(const char *name) 105 { 106 const struct pt_regs_offset *roff; 107 for (roff = regoffset_table; roff->name != NULL; roff++) 108 if (!strcmp(roff->name, name)) 109 return roff->offset; 110 return -EINVAL; 111 } 112 113 /** 114 * regs_query_register_name() - query register name from its offset 115 * @offset: the offset of a register in struct pt_regs. 116 * 117 * regs_query_register_name() returns the name of a register from its 118 * offset in struct pt_regs. If the @offset is invalid, this returns NULL; 119 */ 120 const char *regs_query_register_name(unsigned int offset) 121 { 122 const struct pt_regs_offset *roff; 123 for (roff = regoffset_table; roff->name != NULL; roff++) 124 if (roff->offset == offset) 125 return roff->name; 126 return NULL; 127 } 128 129 static const int arg_offs_table[] = { 130 #ifdef CONFIG_X86_32 131 [0] = offsetof(struct pt_regs, ax), 132 [1] = offsetof(struct pt_regs, dx), 133 [2] = offsetof(struct pt_regs, cx) 134 #else /* CONFIG_X86_64 */ 135 [0] = offsetof(struct pt_regs, di), 136 [1] = offsetof(struct pt_regs, si), 137 [2] = offsetof(struct pt_regs, dx), 138 [3] = offsetof(struct pt_regs, cx), 139 [4] = offsetof(struct pt_regs, r8), 140 [5] = offsetof(struct pt_regs, r9) 141 #endif 142 }; 143 144 /* 145 * does not yet catch signals sent when the child dies. 146 * in exit.c or in signal.c. 147 */ 148 149 /* 150 * Determines which flags the user has access to [1 = access, 0 = no access]. 151 */ 152 #define FLAG_MASK_32 ((unsigned long) \ 153 (X86_EFLAGS_CF | X86_EFLAGS_PF | \ 154 X86_EFLAGS_AF | X86_EFLAGS_ZF | \ 155 X86_EFLAGS_SF | X86_EFLAGS_TF | \ 156 X86_EFLAGS_DF | X86_EFLAGS_OF | \ 157 X86_EFLAGS_RF | X86_EFLAGS_AC)) 158 159 /* 160 * Determines whether a value may be installed in a segment register. 161 */ 162 static inline bool invalid_selector(u16 value) 163 { 164 return unlikely(value != 0 && (value & SEGMENT_RPL_MASK) != USER_RPL); 165 } 166 167 #ifdef CONFIG_X86_32 168 169 #define FLAG_MASK FLAG_MASK_32 170 171 /* 172 * X86_32 CPUs don't save ss and esp if the CPU is already in kernel mode 173 * when it traps. The previous stack will be directly underneath the saved 174 * registers, and 'sp/ss' won't even have been saved. Thus the '®s->sp'. 175 * 176 * Now, if the stack is empty, '®s->sp' is out of range. In this 177 * case we try to take the previous stack. To always return a non-null 178 * stack pointer we fall back to regs as stack if no previous stack 179 * exists. 180 * 181 * This is valid only for kernel mode traps. 182 */ 183 unsigned long kernel_stack_pointer(struct pt_regs *regs) 184 { 185 unsigned long context = (unsigned long)regs & ~(THREAD_SIZE - 1); 186 unsigned long sp = (unsigned long)®s->sp; 187 struct thread_info *tinfo; 188 189 if (context == (sp & ~(THREAD_SIZE - 1))) 190 return sp; 191 192 tinfo = (struct thread_info *)context; 193 if (tinfo->previous_esp) 194 return tinfo->previous_esp; 195 196 return (unsigned long)regs; 197 } 198 EXPORT_SYMBOL_GPL(kernel_stack_pointer); 199 200 static unsigned long *pt_regs_access(struct pt_regs *regs, unsigned long regno) 201 { 202 BUILD_BUG_ON(offsetof(struct pt_regs, bx) != 0); 203 return ®s->bx + (regno >> 2); 204 } 205 206 static u16 get_segment_reg(struct task_struct *task, unsigned long offset) 207 { 208 /* 209 * Returning the value truncates it to 16 bits. 210 */ 211 unsigned int retval; 212 if (offset != offsetof(struct user_regs_struct, gs)) 213 retval = *pt_regs_access(task_pt_regs(task), offset); 214 else { 215 if (task == current) 216 retval = get_user_gs(task_pt_regs(task)); 217 else 218 retval = task_user_gs(task); 219 } 220 return retval; 221 } 222 223 static int set_segment_reg(struct task_struct *task, 224 unsigned long offset, u16 value) 225 { 226 /* 227 * The value argument was already truncated to 16 bits. 228 */ 229 if (invalid_selector(value)) 230 return -EIO; 231 232 /* 233 * For %cs and %ss we cannot permit a null selector. 234 * We can permit a bogus selector as long as it has USER_RPL. 235 * Null selectors are fine for other segment registers, but 236 * we will never get back to user mode with invalid %cs or %ss 237 * and will take the trap in iret instead. Much code relies 238 * on user_mode() to distinguish a user trap frame (which can 239 * safely use invalid selectors) from a kernel trap frame. 240 */ 241 switch (offset) { 242 case offsetof(struct user_regs_struct, cs): 243 case offsetof(struct user_regs_struct, ss): 244 if (unlikely(value == 0)) 245 return -EIO; 246 247 default: 248 *pt_regs_access(task_pt_regs(task), offset) = value; 249 break; 250 251 case offsetof(struct user_regs_struct, gs): 252 if (task == current) 253 set_user_gs(task_pt_regs(task), value); 254 else 255 task_user_gs(task) = value; 256 } 257 258 return 0; 259 } 260 261 #else /* CONFIG_X86_64 */ 262 263 #define FLAG_MASK (FLAG_MASK_32 | X86_EFLAGS_NT) 264 265 static unsigned long *pt_regs_access(struct pt_regs *regs, unsigned long offset) 266 { 267 BUILD_BUG_ON(offsetof(struct pt_regs, r15) != 0); 268 return ®s->r15 + (offset / sizeof(regs->r15)); 269 } 270 271 static u16 get_segment_reg(struct task_struct *task, unsigned long offset) 272 { 273 /* 274 * Returning the value truncates it to 16 bits. 275 */ 276 unsigned int seg; 277 278 switch (offset) { 279 case offsetof(struct user_regs_struct, fs): 280 if (task == current) { 281 /* Older gas can't assemble movq %?s,%r?? */ 282 asm("movl %%fs,%0" : "=r" (seg)); 283 return seg; 284 } 285 return task->thread.fsindex; 286 case offsetof(struct user_regs_struct, gs): 287 if (task == current) { 288 asm("movl %%gs,%0" : "=r" (seg)); 289 return seg; 290 } 291 return task->thread.gsindex; 292 case offsetof(struct user_regs_struct, ds): 293 if (task == current) { 294 asm("movl %%ds,%0" : "=r" (seg)); 295 return seg; 296 } 297 return task->thread.ds; 298 case offsetof(struct user_regs_struct, es): 299 if (task == current) { 300 asm("movl %%es,%0" : "=r" (seg)); 301 return seg; 302 } 303 return task->thread.es; 304 305 case offsetof(struct user_regs_struct, cs): 306 case offsetof(struct user_regs_struct, ss): 307 break; 308 } 309 return *pt_regs_access(task_pt_regs(task), offset); 310 } 311 312 static int set_segment_reg(struct task_struct *task, 313 unsigned long offset, u16 value) 314 { 315 /* 316 * The value argument was already truncated to 16 bits. 317 */ 318 if (invalid_selector(value)) 319 return -EIO; 320 321 switch (offset) { 322 case offsetof(struct user_regs_struct,fs): 323 /* 324 * If this is setting fs as for normal 64-bit use but 325 * setting fs_base has implicitly changed it, leave it. 326 */ 327 if ((value == FS_TLS_SEL && task->thread.fsindex == 0 && 328 task->thread.fs != 0) || 329 (value == 0 && task->thread.fsindex == FS_TLS_SEL && 330 task->thread.fs == 0)) 331 break; 332 task->thread.fsindex = value; 333 if (task == current) 334 loadsegment(fs, task->thread.fsindex); 335 break; 336 case offsetof(struct user_regs_struct,gs): 337 /* 338 * If this is setting gs as for normal 64-bit use but 339 * setting gs_base has implicitly changed it, leave it. 340 */ 341 if ((value == GS_TLS_SEL && task->thread.gsindex == 0 && 342 task->thread.gs != 0) || 343 (value == 0 && task->thread.gsindex == GS_TLS_SEL && 344 task->thread.gs == 0)) 345 break; 346 task->thread.gsindex = value; 347 if (task == current) 348 load_gs_index(task->thread.gsindex); 349 break; 350 case offsetof(struct user_regs_struct,ds): 351 task->thread.ds = value; 352 if (task == current) 353 loadsegment(ds, task->thread.ds); 354 break; 355 case offsetof(struct user_regs_struct,es): 356 task->thread.es = value; 357 if (task == current) 358 loadsegment(es, task->thread.es); 359 break; 360 361 /* 362 * Can't actually change these in 64-bit mode. 363 */ 364 case offsetof(struct user_regs_struct,cs): 365 if (unlikely(value == 0)) 366 return -EIO; 367 #ifdef CONFIG_IA32_EMULATION 368 if (test_tsk_thread_flag(task, TIF_IA32)) 369 task_pt_regs(task)->cs = value; 370 #endif 371 break; 372 case offsetof(struct user_regs_struct,ss): 373 if (unlikely(value == 0)) 374 return -EIO; 375 #ifdef CONFIG_IA32_EMULATION 376 if (test_tsk_thread_flag(task, TIF_IA32)) 377 task_pt_regs(task)->ss = value; 378 #endif 379 break; 380 } 381 382 return 0; 383 } 384 385 #endif /* CONFIG_X86_32 */ 386 387 static unsigned long get_flags(struct task_struct *task) 388 { 389 unsigned long retval = task_pt_regs(task)->flags; 390 391 /* 392 * If the debugger set TF, hide it from the readout. 393 */ 394 if (test_tsk_thread_flag(task, TIF_FORCED_TF)) 395 retval &= ~X86_EFLAGS_TF; 396 397 return retval; 398 } 399 400 static int set_flags(struct task_struct *task, unsigned long value) 401 { 402 struct pt_regs *regs = task_pt_regs(task); 403 404 /* 405 * If the user value contains TF, mark that 406 * it was not "us" (the debugger) that set it. 407 * If not, make sure it stays set if we had. 408 */ 409 if (value & X86_EFLAGS_TF) 410 clear_tsk_thread_flag(task, TIF_FORCED_TF); 411 else if (test_tsk_thread_flag(task, TIF_FORCED_TF)) 412 value |= X86_EFLAGS_TF; 413 414 regs->flags = (regs->flags & ~FLAG_MASK) | (value & FLAG_MASK); 415 416 return 0; 417 } 418 419 static int putreg(struct task_struct *child, 420 unsigned long offset, unsigned long value) 421 { 422 switch (offset) { 423 case offsetof(struct user_regs_struct, cs): 424 case offsetof(struct user_regs_struct, ds): 425 case offsetof(struct user_regs_struct, es): 426 case offsetof(struct user_regs_struct, fs): 427 case offsetof(struct user_regs_struct, gs): 428 case offsetof(struct user_regs_struct, ss): 429 return set_segment_reg(child, offset, value); 430 431 case offsetof(struct user_regs_struct, flags): 432 return set_flags(child, value); 433 434 #ifdef CONFIG_X86_64 435 case offsetof(struct user_regs_struct,fs_base): 436 if (value >= TASK_SIZE_OF(child)) 437 return -EIO; 438 /* 439 * When changing the segment base, use do_arch_prctl 440 * to set either thread.fs or thread.fsindex and the 441 * corresponding GDT slot. 442 */ 443 if (child->thread.fs != value) 444 return do_arch_prctl(child, ARCH_SET_FS, value); 445 return 0; 446 case offsetof(struct user_regs_struct,gs_base): 447 /* 448 * Exactly the same here as the %fs handling above. 449 */ 450 if (value >= TASK_SIZE_OF(child)) 451 return -EIO; 452 if (child->thread.gs != value) 453 return do_arch_prctl(child, ARCH_SET_GS, value); 454 return 0; 455 #endif 456 } 457 458 *pt_regs_access(task_pt_regs(child), offset) = value; 459 return 0; 460 } 461 462 static unsigned long getreg(struct task_struct *task, unsigned long offset) 463 { 464 switch (offset) { 465 case offsetof(struct user_regs_struct, cs): 466 case offsetof(struct user_regs_struct, ds): 467 case offsetof(struct user_regs_struct, es): 468 case offsetof(struct user_regs_struct, fs): 469 case offsetof(struct user_regs_struct, gs): 470 case offsetof(struct user_regs_struct, ss): 471 return get_segment_reg(task, offset); 472 473 case offsetof(struct user_regs_struct, flags): 474 return get_flags(task); 475 476 #ifdef CONFIG_X86_64 477 case offsetof(struct user_regs_struct, fs_base): { 478 /* 479 * do_arch_prctl may have used a GDT slot instead of 480 * the MSR. To userland, it appears the same either 481 * way, except the %fs segment selector might not be 0. 482 */ 483 unsigned int seg = task->thread.fsindex; 484 if (task->thread.fs != 0) 485 return task->thread.fs; 486 if (task == current) 487 asm("movl %%fs,%0" : "=r" (seg)); 488 if (seg != FS_TLS_SEL) 489 return 0; 490 return get_desc_base(&task->thread.tls_array[FS_TLS]); 491 } 492 case offsetof(struct user_regs_struct, gs_base): { 493 /* 494 * Exactly the same here as the %fs handling above. 495 */ 496 unsigned int seg = task->thread.gsindex; 497 if (task->thread.gs != 0) 498 return task->thread.gs; 499 if (task == current) 500 asm("movl %%gs,%0" : "=r" (seg)); 501 if (seg != GS_TLS_SEL) 502 return 0; 503 return get_desc_base(&task->thread.tls_array[GS_TLS]); 504 } 505 #endif 506 } 507 508 return *pt_regs_access(task_pt_regs(task), offset); 509 } 510 511 static int genregs_get(struct task_struct *target, 512 const struct user_regset *regset, 513 unsigned int pos, unsigned int count, 514 void *kbuf, void __user *ubuf) 515 { 516 if (kbuf) { 517 unsigned long *k = kbuf; 518 while (count >= sizeof(*k)) { 519 *k++ = getreg(target, pos); 520 count -= sizeof(*k); 521 pos += sizeof(*k); 522 } 523 } else { 524 unsigned long __user *u = ubuf; 525 while (count >= sizeof(*u)) { 526 if (__put_user(getreg(target, pos), u++)) 527 return -EFAULT; 528 count -= sizeof(*u); 529 pos += sizeof(*u); 530 } 531 } 532 533 return 0; 534 } 535 536 static int genregs_set(struct task_struct *target, 537 const struct user_regset *regset, 538 unsigned int pos, unsigned int count, 539 const void *kbuf, const void __user *ubuf) 540 { 541 int ret = 0; 542 if (kbuf) { 543 const unsigned long *k = kbuf; 544 while (count >= sizeof(*k) && !ret) { 545 ret = putreg(target, pos, *k++); 546 count -= sizeof(*k); 547 pos += sizeof(*k); 548 } 549 } else { 550 const unsigned long __user *u = ubuf; 551 while (count >= sizeof(*u) && !ret) { 552 unsigned long word; 553 ret = __get_user(word, u++); 554 if (ret) 555 break; 556 ret = putreg(target, pos, word); 557 count -= sizeof(*u); 558 pos += sizeof(*u); 559 } 560 } 561 return ret; 562 } 563 564 static void ptrace_triggered(struct perf_event *bp, 565 struct perf_sample_data *data, 566 struct pt_regs *regs) 567 { 568 int i; 569 struct thread_struct *thread = &(current->thread); 570 571 /* 572 * Store in the virtual DR6 register the fact that the breakpoint 573 * was hit so the thread's debugger will see it. 574 */ 575 for (i = 0; i < HBP_NUM; i++) { 576 if (thread->ptrace_bps[i] == bp) 577 break; 578 } 579 580 thread->debugreg6 |= (DR_TRAP0 << i); 581 } 582 583 /* 584 * Walk through every ptrace breakpoints for this thread and 585 * build the dr7 value on top of their attributes. 586 * 587 */ 588 static unsigned long ptrace_get_dr7(struct perf_event *bp[]) 589 { 590 int i; 591 int dr7 = 0; 592 struct arch_hw_breakpoint *info; 593 594 for (i = 0; i < HBP_NUM; i++) { 595 if (bp[i] && !bp[i]->attr.disabled) { 596 info = counter_arch_bp(bp[i]); 597 dr7 |= encode_dr7(i, info->len, info->type); 598 } 599 } 600 601 return dr7; 602 } 603 604 static int 605 ptrace_modify_breakpoint(struct perf_event *bp, int len, int type, 606 struct task_struct *tsk, int disabled) 607 { 608 int err; 609 int gen_len, gen_type; 610 struct perf_event_attr attr; 611 612 /* 613 * We should have at least an inactive breakpoint at this 614 * slot. It means the user is writing dr7 without having 615 * written the address register first 616 */ 617 if (!bp) 618 return -EINVAL; 619 620 err = arch_bp_generic_fields(len, type, &gen_len, &gen_type); 621 if (err) 622 return err; 623 624 attr = bp->attr; 625 attr.bp_len = gen_len; 626 attr.bp_type = gen_type; 627 attr.disabled = disabled; 628 629 return modify_user_hw_breakpoint(bp, &attr); 630 } 631 632 /* 633 * Handle ptrace writes to debug register 7. 634 */ 635 static int ptrace_write_dr7(struct task_struct *tsk, unsigned long data) 636 { 637 struct thread_struct *thread = &(tsk->thread); 638 unsigned long old_dr7; 639 int i, orig_ret = 0, rc = 0; 640 int enabled, second_pass = 0; 641 unsigned len, type; 642 struct perf_event *bp; 643 644 if (ptrace_get_breakpoints(tsk) < 0) 645 return -ESRCH; 646 647 data &= ~DR_CONTROL_RESERVED; 648 old_dr7 = ptrace_get_dr7(thread->ptrace_bps); 649 restore: 650 /* 651 * Loop through all the hardware breakpoints, making the 652 * appropriate changes to each. 653 */ 654 for (i = 0; i < HBP_NUM; i++) { 655 enabled = decode_dr7(data, i, &len, &type); 656 bp = thread->ptrace_bps[i]; 657 658 if (!enabled) { 659 if (bp) { 660 /* 661 * Don't unregister the breakpoints right-away, 662 * unless all register_user_hw_breakpoint() 663 * requests have succeeded. This prevents 664 * any window of opportunity for debug 665 * register grabbing by other users. 666 */ 667 if (!second_pass) 668 continue; 669 670 rc = ptrace_modify_breakpoint(bp, len, type, 671 tsk, 1); 672 if (rc) 673 break; 674 } 675 continue; 676 } 677 678 rc = ptrace_modify_breakpoint(bp, len, type, tsk, 0); 679 if (rc) 680 break; 681 } 682 /* 683 * Make a second pass to free the remaining unused breakpoints 684 * or to restore the original breakpoints if an error occurred. 685 */ 686 if (!second_pass) { 687 second_pass = 1; 688 if (rc < 0) { 689 orig_ret = rc; 690 data = old_dr7; 691 } 692 goto restore; 693 } 694 695 ptrace_put_breakpoints(tsk); 696 697 return ((orig_ret < 0) ? orig_ret : rc); 698 } 699 700 /* 701 * Handle PTRACE_PEEKUSR calls for the debug register area. 702 */ 703 static unsigned long ptrace_get_debugreg(struct task_struct *tsk, int n) 704 { 705 struct thread_struct *thread = &(tsk->thread); 706 unsigned long val = 0; 707 708 if (n < HBP_NUM) { 709 struct perf_event *bp; 710 711 if (ptrace_get_breakpoints(tsk) < 0) 712 return -ESRCH; 713 714 bp = thread->ptrace_bps[n]; 715 if (!bp) 716 val = 0; 717 else 718 val = bp->hw.info.address; 719 720 ptrace_put_breakpoints(tsk); 721 } else if (n == 6) { 722 val = thread->debugreg6; 723 } else if (n == 7) { 724 val = thread->ptrace_dr7; 725 } 726 return val; 727 } 728 729 static int ptrace_set_breakpoint_addr(struct task_struct *tsk, int nr, 730 unsigned long addr) 731 { 732 struct perf_event *bp; 733 struct thread_struct *t = &tsk->thread; 734 struct perf_event_attr attr; 735 int err = 0; 736 737 if (ptrace_get_breakpoints(tsk) < 0) 738 return -ESRCH; 739 740 if (!t->ptrace_bps[nr]) { 741 ptrace_breakpoint_init(&attr); 742 /* 743 * Put stub len and type to register (reserve) an inactive but 744 * correct bp 745 */ 746 attr.bp_addr = addr; 747 attr.bp_len = HW_BREAKPOINT_LEN_1; 748 attr.bp_type = HW_BREAKPOINT_W; 749 attr.disabled = 1; 750 751 bp = register_user_hw_breakpoint(&attr, ptrace_triggered, 752 NULL, tsk); 753 754 /* 755 * CHECKME: the previous code returned -EIO if the addr wasn't 756 * a valid task virtual addr. The new one will return -EINVAL in 757 * this case. 758 * -EINVAL may be what we want for in-kernel breakpoints users, 759 * but -EIO looks better for ptrace, since we refuse a register 760 * writing for the user. And anyway this is the previous 761 * behaviour. 762 */ 763 if (IS_ERR(bp)) { 764 err = PTR_ERR(bp); 765 goto put; 766 } 767 768 t->ptrace_bps[nr] = bp; 769 } else { 770 bp = t->ptrace_bps[nr]; 771 772 attr = bp->attr; 773 attr.bp_addr = addr; 774 err = modify_user_hw_breakpoint(bp, &attr); 775 } 776 777 put: 778 ptrace_put_breakpoints(tsk); 779 return err; 780 } 781 782 /* 783 * Handle PTRACE_POKEUSR calls for the debug register area. 784 */ 785 static int ptrace_set_debugreg(struct task_struct *tsk, int n, 786 unsigned long val) 787 { 788 struct thread_struct *thread = &(tsk->thread); 789 int rc = 0; 790 791 /* There are no DR4 or DR5 registers */ 792 if (n == 4 || n == 5) 793 return -EIO; 794 795 if (n == 6) { 796 thread->debugreg6 = val; 797 goto ret_path; 798 } 799 if (n < HBP_NUM) { 800 rc = ptrace_set_breakpoint_addr(tsk, n, val); 801 if (rc) 802 return rc; 803 } 804 /* All that's left is DR7 */ 805 if (n == 7) { 806 rc = ptrace_write_dr7(tsk, val); 807 if (!rc) 808 thread->ptrace_dr7 = val; 809 } 810 811 ret_path: 812 return rc; 813 } 814 815 /* 816 * These access the current or another (stopped) task's io permission 817 * bitmap for debugging or core dump. 818 */ 819 static int ioperm_active(struct task_struct *target, 820 const struct user_regset *regset) 821 { 822 return target->thread.io_bitmap_max / regset->size; 823 } 824 825 static int ioperm_get(struct task_struct *target, 826 const struct user_regset *regset, 827 unsigned int pos, unsigned int count, 828 void *kbuf, void __user *ubuf) 829 { 830 if (!target->thread.io_bitmap_ptr) 831 return -ENXIO; 832 833 return user_regset_copyout(&pos, &count, &kbuf, &ubuf, 834 target->thread.io_bitmap_ptr, 835 0, IO_BITMAP_BYTES); 836 } 837 838 /* 839 * Called by kernel/ptrace.c when detaching.. 840 * 841 * Make sure the single step bit is not set. 842 */ 843 void ptrace_disable(struct task_struct *child) 844 { 845 user_disable_single_step(child); 846 #ifdef TIF_SYSCALL_EMU 847 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU); 848 #endif 849 } 850 851 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION 852 static const struct user_regset_view user_x86_32_view; /* Initialized below. */ 853 #endif 854 855 long arch_ptrace(struct task_struct *child, long request, 856 unsigned long addr, unsigned long data) 857 { 858 int ret; 859 unsigned long __user *datap = (unsigned long __user *)data; 860 861 switch (request) { 862 /* read the word at location addr in the USER area. */ 863 case PTRACE_PEEKUSR: { 864 unsigned long tmp; 865 866 ret = -EIO; 867 if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user)) 868 break; 869 870 tmp = 0; /* Default return condition */ 871 if (addr < sizeof(struct user_regs_struct)) 872 tmp = getreg(child, addr); 873 else if (addr >= offsetof(struct user, u_debugreg[0]) && 874 addr <= offsetof(struct user, u_debugreg[7])) { 875 addr -= offsetof(struct user, u_debugreg[0]); 876 tmp = ptrace_get_debugreg(child, addr / sizeof(data)); 877 } 878 ret = put_user(tmp, datap); 879 break; 880 } 881 882 case PTRACE_POKEUSR: /* write the word at location addr in the USER area */ 883 ret = -EIO; 884 if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user)) 885 break; 886 887 if (addr < sizeof(struct user_regs_struct)) 888 ret = putreg(child, addr, data); 889 else if (addr >= offsetof(struct user, u_debugreg[0]) && 890 addr <= offsetof(struct user, u_debugreg[7])) { 891 addr -= offsetof(struct user, u_debugreg[0]); 892 ret = ptrace_set_debugreg(child, 893 addr / sizeof(data), data); 894 } 895 break; 896 897 case PTRACE_GETREGS: /* Get all gp regs from the child. */ 898 return copy_regset_to_user(child, 899 task_user_regset_view(current), 900 REGSET_GENERAL, 901 0, sizeof(struct user_regs_struct), 902 datap); 903 904 case PTRACE_SETREGS: /* Set all gp regs in the child. */ 905 return copy_regset_from_user(child, 906 task_user_regset_view(current), 907 REGSET_GENERAL, 908 0, sizeof(struct user_regs_struct), 909 datap); 910 911 case PTRACE_GETFPREGS: /* Get the child FPU state. */ 912 return copy_regset_to_user(child, 913 task_user_regset_view(current), 914 REGSET_FP, 915 0, sizeof(struct user_i387_struct), 916 datap); 917 918 case PTRACE_SETFPREGS: /* Set the child FPU state. */ 919 return copy_regset_from_user(child, 920 task_user_regset_view(current), 921 REGSET_FP, 922 0, sizeof(struct user_i387_struct), 923 datap); 924 925 #ifdef CONFIG_X86_32 926 case PTRACE_GETFPXREGS: /* Get the child extended FPU state. */ 927 return copy_regset_to_user(child, &user_x86_32_view, 928 REGSET_XFP, 929 0, sizeof(struct user_fxsr_struct), 930 datap) ? -EIO : 0; 931 932 case PTRACE_SETFPXREGS: /* Set the child extended FPU state. */ 933 return copy_regset_from_user(child, &user_x86_32_view, 934 REGSET_XFP, 935 0, sizeof(struct user_fxsr_struct), 936 datap) ? -EIO : 0; 937 #endif 938 939 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION 940 case PTRACE_GET_THREAD_AREA: 941 if ((int) addr < 0) 942 return -EIO; 943 ret = do_get_thread_area(child, addr, 944 (struct user_desc __user *)data); 945 break; 946 947 case PTRACE_SET_THREAD_AREA: 948 if ((int) addr < 0) 949 return -EIO; 950 ret = do_set_thread_area(child, addr, 951 (struct user_desc __user *)data, 0); 952 break; 953 #endif 954 955 #ifdef CONFIG_X86_64 956 /* normal 64bit interface to access TLS data. 957 Works just like arch_prctl, except that the arguments 958 are reversed. */ 959 case PTRACE_ARCH_PRCTL: 960 ret = do_arch_prctl(child, data, addr); 961 break; 962 #endif 963 964 default: 965 ret = ptrace_request(child, request, addr, data); 966 break; 967 } 968 969 return ret; 970 } 971 972 #ifdef CONFIG_IA32_EMULATION 973 974 #include <linux/compat.h> 975 #include <linux/syscalls.h> 976 #include <asm/ia32.h> 977 #include <asm/user32.h> 978 979 #define R32(l,q) \ 980 case offsetof(struct user32, regs.l): \ 981 regs->q = value; break 982 983 #define SEG32(rs) \ 984 case offsetof(struct user32, regs.rs): \ 985 return set_segment_reg(child, \ 986 offsetof(struct user_regs_struct, rs), \ 987 value); \ 988 break 989 990 static int putreg32(struct task_struct *child, unsigned regno, u32 value) 991 { 992 struct pt_regs *regs = task_pt_regs(child); 993 994 switch (regno) { 995 996 SEG32(cs); 997 SEG32(ds); 998 SEG32(es); 999 SEG32(fs); 1000 SEG32(gs); 1001 SEG32(ss); 1002 1003 R32(ebx, bx); 1004 R32(ecx, cx); 1005 R32(edx, dx); 1006 R32(edi, di); 1007 R32(esi, si); 1008 R32(ebp, bp); 1009 R32(eax, ax); 1010 R32(eip, ip); 1011 R32(esp, sp); 1012 1013 case offsetof(struct user32, regs.orig_eax): 1014 /* 1015 * A 32-bit debugger setting orig_eax means to restore 1016 * the state of the task restarting a 32-bit syscall. 1017 * Make sure we interpret the -ERESTART* codes correctly 1018 * in case the task is not actually still sitting at the 1019 * exit from a 32-bit syscall with TS_COMPAT still set. 1020 */ 1021 regs->orig_ax = value; 1022 if (syscall_get_nr(child, regs) >= 0) 1023 task_thread_info(child)->status |= TS_COMPAT; 1024 break; 1025 1026 case offsetof(struct user32, regs.eflags): 1027 return set_flags(child, value); 1028 1029 case offsetof(struct user32, u_debugreg[0]) ... 1030 offsetof(struct user32, u_debugreg[7]): 1031 regno -= offsetof(struct user32, u_debugreg[0]); 1032 return ptrace_set_debugreg(child, regno / 4, value); 1033 1034 default: 1035 if (regno > sizeof(struct user32) || (regno & 3)) 1036 return -EIO; 1037 1038 /* 1039 * Other dummy fields in the virtual user structure 1040 * are ignored 1041 */ 1042 break; 1043 } 1044 return 0; 1045 } 1046 1047 #undef R32 1048 #undef SEG32 1049 1050 #define R32(l,q) \ 1051 case offsetof(struct user32, regs.l): \ 1052 *val = regs->q; break 1053 1054 #define SEG32(rs) \ 1055 case offsetof(struct user32, regs.rs): \ 1056 *val = get_segment_reg(child, \ 1057 offsetof(struct user_regs_struct, rs)); \ 1058 break 1059 1060 static int getreg32(struct task_struct *child, unsigned regno, u32 *val) 1061 { 1062 struct pt_regs *regs = task_pt_regs(child); 1063 1064 switch (regno) { 1065 1066 SEG32(ds); 1067 SEG32(es); 1068 SEG32(fs); 1069 SEG32(gs); 1070 1071 R32(cs, cs); 1072 R32(ss, ss); 1073 R32(ebx, bx); 1074 R32(ecx, cx); 1075 R32(edx, dx); 1076 R32(edi, di); 1077 R32(esi, si); 1078 R32(ebp, bp); 1079 R32(eax, ax); 1080 R32(orig_eax, orig_ax); 1081 R32(eip, ip); 1082 R32(esp, sp); 1083 1084 case offsetof(struct user32, regs.eflags): 1085 *val = get_flags(child); 1086 break; 1087 1088 case offsetof(struct user32, u_debugreg[0]) ... 1089 offsetof(struct user32, u_debugreg[7]): 1090 regno -= offsetof(struct user32, u_debugreg[0]); 1091 *val = ptrace_get_debugreg(child, regno / 4); 1092 break; 1093 1094 default: 1095 if (regno > sizeof(struct user32) || (regno & 3)) 1096 return -EIO; 1097 1098 /* 1099 * Other dummy fields in the virtual user structure 1100 * are ignored 1101 */ 1102 *val = 0; 1103 break; 1104 } 1105 return 0; 1106 } 1107 1108 #undef R32 1109 #undef SEG32 1110 1111 static int genregs32_get(struct task_struct *target, 1112 const struct user_regset *regset, 1113 unsigned int pos, unsigned int count, 1114 void *kbuf, void __user *ubuf) 1115 { 1116 if (kbuf) { 1117 compat_ulong_t *k = kbuf; 1118 while (count >= sizeof(*k)) { 1119 getreg32(target, pos, k++); 1120 count -= sizeof(*k); 1121 pos += sizeof(*k); 1122 } 1123 } else { 1124 compat_ulong_t __user *u = ubuf; 1125 while (count >= sizeof(*u)) { 1126 compat_ulong_t word; 1127 getreg32(target, pos, &word); 1128 if (__put_user(word, u++)) 1129 return -EFAULT; 1130 count -= sizeof(*u); 1131 pos += sizeof(*u); 1132 } 1133 } 1134 1135 return 0; 1136 } 1137 1138 static int genregs32_set(struct task_struct *target, 1139 const struct user_regset *regset, 1140 unsigned int pos, unsigned int count, 1141 const void *kbuf, const void __user *ubuf) 1142 { 1143 int ret = 0; 1144 if (kbuf) { 1145 const compat_ulong_t *k = kbuf; 1146 while (count >= sizeof(*k) && !ret) { 1147 ret = putreg32(target, pos, *k++); 1148 count -= sizeof(*k); 1149 pos += sizeof(*k); 1150 } 1151 } else { 1152 const compat_ulong_t __user *u = ubuf; 1153 while (count >= sizeof(*u) && !ret) { 1154 compat_ulong_t word; 1155 ret = __get_user(word, u++); 1156 if (ret) 1157 break; 1158 ret = putreg32(target, pos, word); 1159 count -= sizeof(*u); 1160 pos += sizeof(*u); 1161 } 1162 } 1163 return ret; 1164 } 1165 1166 #ifdef CONFIG_X86_X32_ABI 1167 static long x32_arch_ptrace(struct task_struct *child, 1168 compat_long_t request, compat_ulong_t caddr, 1169 compat_ulong_t cdata) 1170 { 1171 unsigned long addr = caddr; 1172 unsigned long data = cdata; 1173 void __user *datap = compat_ptr(data); 1174 int ret; 1175 1176 switch (request) { 1177 /* Read 32bits at location addr in the USER area. Only allow 1178 to return the lower 32bits of segment and debug registers. */ 1179 case PTRACE_PEEKUSR: { 1180 u32 tmp; 1181 1182 ret = -EIO; 1183 if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user) || 1184 addr < offsetof(struct user_regs_struct, cs)) 1185 break; 1186 1187 tmp = 0; /* Default return condition */ 1188 if (addr < sizeof(struct user_regs_struct)) 1189 tmp = getreg(child, addr); 1190 else if (addr >= offsetof(struct user, u_debugreg[0]) && 1191 addr <= offsetof(struct user, u_debugreg[7])) { 1192 addr -= offsetof(struct user, u_debugreg[0]); 1193 tmp = ptrace_get_debugreg(child, addr / sizeof(data)); 1194 } 1195 ret = put_user(tmp, (__u32 __user *)datap); 1196 break; 1197 } 1198 1199 /* Write the word at location addr in the USER area. Only allow 1200 to update segment and debug registers with the upper 32bits 1201 zero-extended. */ 1202 case PTRACE_POKEUSR: 1203 ret = -EIO; 1204 if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user) || 1205 addr < offsetof(struct user_regs_struct, cs)) 1206 break; 1207 1208 if (addr < sizeof(struct user_regs_struct)) 1209 ret = putreg(child, addr, data); 1210 else if (addr >= offsetof(struct user, u_debugreg[0]) && 1211 addr <= offsetof(struct user, u_debugreg[7])) { 1212 addr -= offsetof(struct user, u_debugreg[0]); 1213 ret = ptrace_set_debugreg(child, 1214 addr / sizeof(data), data); 1215 } 1216 break; 1217 1218 case PTRACE_GETREGS: /* Get all gp regs from the child. */ 1219 return copy_regset_to_user(child, 1220 task_user_regset_view(current), 1221 REGSET_GENERAL, 1222 0, sizeof(struct user_regs_struct), 1223 datap); 1224 1225 case PTRACE_SETREGS: /* Set all gp regs in the child. */ 1226 return copy_regset_from_user(child, 1227 task_user_regset_view(current), 1228 REGSET_GENERAL, 1229 0, sizeof(struct user_regs_struct), 1230 datap); 1231 1232 case PTRACE_GETFPREGS: /* Get the child FPU state. */ 1233 return copy_regset_to_user(child, 1234 task_user_regset_view(current), 1235 REGSET_FP, 1236 0, sizeof(struct user_i387_struct), 1237 datap); 1238 1239 case PTRACE_SETFPREGS: /* Set the child FPU state. */ 1240 return copy_regset_from_user(child, 1241 task_user_regset_view(current), 1242 REGSET_FP, 1243 0, sizeof(struct user_i387_struct), 1244 datap); 1245 1246 default: 1247 return compat_ptrace_request(child, request, addr, data); 1248 } 1249 1250 return ret; 1251 } 1252 #endif 1253 1254 long compat_arch_ptrace(struct task_struct *child, compat_long_t request, 1255 compat_ulong_t caddr, compat_ulong_t cdata) 1256 { 1257 unsigned long addr = caddr; 1258 unsigned long data = cdata; 1259 void __user *datap = compat_ptr(data); 1260 int ret; 1261 __u32 val; 1262 1263 #ifdef CONFIG_X86_X32_ABI 1264 if (!is_ia32_task()) 1265 return x32_arch_ptrace(child, request, caddr, cdata); 1266 #endif 1267 1268 switch (request) { 1269 case PTRACE_PEEKUSR: 1270 ret = getreg32(child, addr, &val); 1271 if (ret == 0) 1272 ret = put_user(val, (__u32 __user *)datap); 1273 break; 1274 1275 case PTRACE_POKEUSR: 1276 ret = putreg32(child, addr, data); 1277 break; 1278 1279 case PTRACE_GETREGS: /* Get all gp regs from the child. */ 1280 return copy_regset_to_user(child, &user_x86_32_view, 1281 REGSET_GENERAL, 1282 0, sizeof(struct user_regs_struct32), 1283 datap); 1284 1285 case PTRACE_SETREGS: /* Set all gp regs in the child. */ 1286 return copy_regset_from_user(child, &user_x86_32_view, 1287 REGSET_GENERAL, 0, 1288 sizeof(struct user_regs_struct32), 1289 datap); 1290 1291 case PTRACE_GETFPREGS: /* Get the child FPU state. */ 1292 return copy_regset_to_user(child, &user_x86_32_view, 1293 REGSET_FP, 0, 1294 sizeof(struct user_i387_ia32_struct), 1295 datap); 1296 1297 case PTRACE_SETFPREGS: /* Set the child FPU state. */ 1298 return copy_regset_from_user( 1299 child, &user_x86_32_view, REGSET_FP, 1300 0, sizeof(struct user_i387_ia32_struct), datap); 1301 1302 case PTRACE_GETFPXREGS: /* Get the child extended FPU state. */ 1303 return copy_regset_to_user(child, &user_x86_32_view, 1304 REGSET_XFP, 0, 1305 sizeof(struct user32_fxsr_struct), 1306 datap); 1307 1308 case PTRACE_SETFPXREGS: /* Set the child extended FPU state. */ 1309 return copy_regset_from_user(child, &user_x86_32_view, 1310 REGSET_XFP, 0, 1311 sizeof(struct user32_fxsr_struct), 1312 datap); 1313 1314 case PTRACE_GET_THREAD_AREA: 1315 case PTRACE_SET_THREAD_AREA: 1316 return arch_ptrace(child, request, addr, data); 1317 1318 default: 1319 return compat_ptrace_request(child, request, addr, data); 1320 } 1321 1322 return ret; 1323 } 1324 1325 #endif /* CONFIG_IA32_EMULATION */ 1326 1327 #ifdef CONFIG_X86_64 1328 1329 static struct user_regset x86_64_regsets[] __read_mostly = { 1330 [REGSET_GENERAL] = { 1331 .core_note_type = NT_PRSTATUS, 1332 .n = sizeof(struct user_regs_struct) / sizeof(long), 1333 .size = sizeof(long), .align = sizeof(long), 1334 .get = genregs_get, .set = genregs_set 1335 }, 1336 [REGSET_FP] = { 1337 .core_note_type = NT_PRFPREG, 1338 .n = sizeof(struct user_i387_struct) / sizeof(long), 1339 .size = sizeof(long), .align = sizeof(long), 1340 .active = xfpregs_active, .get = xfpregs_get, .set = xfpregs_set 1341 }, 1342 [REGSET_XSTATE] = { 1343 .core_note_type = NT_X86_XSTATE, 1344 .size = sizeof(u64), .align = sizeof(u64), 1345 .active = xstateregs_active, .get = xstateregs_get, 1346 .set = xstateregs_set 1347 }, 1348 [REGSET_IOPERM64] = { 1349 .core_note_type = NT_386_IOPERM, 1350 .n = IO_BITMAP_LONGS, 1351 .size = sizeof(long), .align = sizeof(long), 1352 .active = ioperm_active, .get = ioperm_get 1353 }, 1354 }; 1355 1356 static const struct user_regset_view user_x86_64_view = { 1357 .name = "x86_64", .e_machine = EM_X86_64, 1358 .regsets = x86_64_regsets, .n = ARRAY_SIZE(x86_64_regsets) 1359 }; 1360 1361 #else /* CONFIG_X86_32 */ 1362 1363 #define user_regs_struct32 user_regs_struct 1364 #define genregs32_get genregs_get 1365 #define genregs32_set genregs_set 1366 1367 #endif /* CONFIG_X86_64 */ 1368 1369 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION 1370 static struct user_regset x86_32_regsets[] __read_mostly = { 1371 [REGSET_GENERAL] = { 1372 .core_note_type = NT_PRSTATUS, 1373 .n = sizeof(struct user_regs_struct32) / sizeof(u32), 1374 .size = sizeof(u32), .align = sizeof(u32), 1375 .get = genregs32_get, .set = genregs32_set 1376 }, 1377 [REGSET_FP] = { 1378 .core_note_type = NT_PRFPREG, 1379 .n = sizeof(struct user_i387_ia32_struct) / sizeof(u32), 1380 .size = sizeof(u32), .align = sizeof(u32), 1381 .active = fpregs_active, .get = fpregs_get, .set = fpregs_set 1382 }, 1383 [REGSET_XFP] = { 1384 .core_note_type = NT_PRXFPREG, 1385 .n = sizeof(struct user32_fxsr_struct) / sizeof(u32), 1386 .size = sizeof(u32), .align = sizeof(u32), 1387 .active = xfpregs_active, .get = xfpregs_get, .set = xfpregs_set 1388 }, 1389 [REGSET_XSTATE] = { 1390 .core_note_type = NT_X86_XSTATE, 1391 .size = sizeof(u64), .align = sizeof(u64), 1392 .active = xstateregs_active, .get = xstateregs_get, 1393 .set = xstateregs_set 1394 }, 1395 [REGSET_TLS] = { 1396 .core_note_type = NT_386_TLS, 1397 .n = GDT_ENTRY_TLS_ENTRIES, .bias = GDT_ENTRY_TLS_MIN, 1398 .size = sizeof(struct user_desc), 1399 .align = sizeof(struct user_desc), 1400 .active = regset_tls_active, 1401 .get = regset_tls_get, .set = regset_tls_set 1402 }, 1403 [REGSET_IOPERM32] = { 1404 .core_note_type = NT_386_IOPERM, 1405 .n = IO_BITMAP_BYTES / sizeof(u32), 1406 .size = sizeof(u32), .align = sizeof(u32), 1407 .active = ioperm_active, .get = ioperm_get 1408 }, 1409 }; 1410 1411 static const struct user_regset_view user_x86_32_view = { 1412 .name = "i386", .e_machine = EM_386, 1413 .regsets = x86_32_regsets, .n = ARRAY_SIZE(x86_32_regsets) 1414 }; 1415 #endif 1416 1417 /* 1418 * This represents bytes 464..511 in the memory layout exported through 1419 * the REGSET_XSTATE interface. 1420 */ 1421 u64 xstate_fx_sw_bytes[USER_XSTATE_FX_SW_WORDS]; 1422 1423 void update_regset_xstate_info(unsigned int size, u64 xstate_mask) 1424 { 1425 #ifdef CONFIG_X86_64 1426 x86_64_regsets[REGSET_XSTATE].n = size / sizeof(u64); 1427 #endif 1428 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION 1429 x86_32_regsets[REGSET_XSTATE].n = size / sizeof(u64); 1430 #endif 1431 xstate_fx_sw_bytes[USER_XSTATE_XCR0_WORD] = xstate_mask; 1432 } 1433 1434 const struct user_regset_view *task_user_regset_view(struct task_struct *task) 1435 { 1436 #ifdef CONFIG_IA32_EMULATION 1437 if (test_tsk_thread_flag(task, TIF_IA32)) 1438 #endif 1439 #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION 1440 return &user_x86_32_view; 1441 #endif 1442 #ifdef CONFIG_X86_64 1443 return &user_x86_64_view; 1444 #endif 1445 } 1446 1447 static void fill_sigtrap_info(struct task_struct *tsk, 1448 struct pt_regs *regs, 1449 int error_code, int si_code, 1450 struct siginfo *info) 1451 { 1452 tsk->thread.trap_nr = X86_TRAP_DB; 1453 tsk->thread.error_code = error_code; 1454 1455 memset(info, 0, sizeof(*info)); 1456 info->si_signo = SIGTRAP; 1457 info->si_code = si_code; 1458 info->si_addr = user_mode_vm(regs) ? (void __user *)regs->ip : NULL; 1459 } 1460 1461 void user_single_step_siginfo(struct task_struct *tsk, 1462 struct pt_regs *regs, 1463 struct siginfo *info) 1464 { 1465 fill_sigtrap_info(tsk, regs, 0, TRAP_BRKPT, info); 1466 } 1467 1468 void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs, 1469 int error_code, int si_code) 1470 { 1471 struct siginfo info; 1472 1473 fill_sigtrap_info(tsk, regs, error_code, si_code, &info); 1474 /* Send us the fake SIGTRAP */ 1475 force_sig_info(SIGTRAP, &info, tsk); 1476 } 1477 1478 1479 #ifdef CONFIG_X86_32 1480 # define IS_IA32 1 1481 #elif defined CONFIG_IA32_EMULATION 1482 # define IS_IA32 is_compat_task() 1483 #else 1484 # define IS_IA32 0 1485 #endif 1486 1487 /* 1488 * We must return the syscall number to actually look up in the table. 1489 * This can be -1L to skip running any syscall at all. 1490 */ 1491 long syscall_trace_enter(struct pt_regs *regs) 1492 { 1493 long ret = 0; 1494 1495 user_exit(); 1496 1497 /* 1498 * If we stepped into a sysenter/syscall insn, it trapped in 1499 * kernel mode; do_debug() cleared TF and set TIF_SINGLESTEP. 1500 * If user-mode had set TF itself, then it's still clear from 1501 * do_debug() and we need to set it again to restore the user 1502 * state. If we entered on the slow path, TF was already set. 1503 */ 1504 if (test_thread_flag(TIF_SINGLESTEP)) 1505 regs->flags |= X86_EFLAGS_TF; 1506 1507 /* do the secure computing check first */ 1508 if (secure_computing(regs->orig_ax)) { 1509 /* seccomp failures shouldn't expose any additional code. */ 1510 ret = -1L; 1511 goto out; 1512 } 1513 1514 if (unlikely(test_thread_flag(TIF_SYSCALL_EMU))) 1515 ret = -1L; 1516 1517 if ((ret || test_thread_flag(TIF_SYSCALL_TRACE)) && 1518 tracehook_report_syscall_entry(regs)) 1519 ret = -1L; 1520 1521 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT))) 1522 trace_sys_enter(regs, regs->orig_ax); 1523 1524 if (IS_IA32) 1525 audit_syscall_entry(AUDIT_ARCH_I386, 1526 regs->orig_ax, 1527 regs->bx, regs->cx, 1528 regs->dx, regs->si); 1529 #ifdef CONFIG_X86_64 1530 else 1531 audit_syscall_entry(AUDIT_ARCH_X86_64, 1532 regs->orig_ax, 1533 regs->di, regs->si, 1534 regs->dx, regs->r10); 1535 #endif 1536 1537 out: 1538 return ret ?: regs->orig_ax; 1539 } 1540 1541 void syscall_trace_leave(struct pt_regs *regs) 1542 { 1543 bool step; 1544 1545 /* 1546 * We may come here right after calling schedule_user() 1547 * or do_notify_resume(), in which case we can be in RCU 1548 * user mode. 1549 */ 1550 user_exit(); 1551 1552 audit_syscall_exit(regs); 1553 1554 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT))) 1555 trace_sys_exit(regs, regs->ax); 1556 1557 /* 1558 * If TIF_SYSCALL_EMU is set, we only get here because of 1559 * TIF_SINGLESTEP (i.e. this is PTRACE_SYSEMU_SINGLESTEP). 1560 * We already reported this syscall instruction in 1561 * syscall_trace_enter(). 1562 */ 1563 step = unlikely(test_thread_flag(TIF_SINGLESTEP)) && 1564 !test_thread_flag(TIF_SYSCALL_EMU); 1565 if (step || test_thread_flag(TIF_SYSCALL_TRACE)) 1566 tracehook_report_syscall_exit(regs, step); 1567 1568 user_enter(); 1569 } 1570