SAFE public projects git trees. - safe/jmp/linux-2.6/blob - kernel/ptrace.c

   1 /*
   2  * linux/kernel/ptrace.c
   3  *
   4  * (C) Copyright 1999 Linus Torvalds
   5  *
   6  * Common interfaces for "ptrace()" which we do not want
   7  * to continually duplicate across every architecture.
   8  */
   9
  10 #include <linux/capability.h>
  11 #include <linux/module.h>
  12 #include <linux/sched.h>
  13 #include <linux/errno.h>
  14 #include <linux/mm.h>
  15 #include <linux/highmem.h>
  16 #include <linux/pagemap.h>
  17 #include <linux/smp_lock.h>
  18 #include <linux/ptrace.h>
  19 #include <linux/security.h>
  20 #include <linux/signal.h>
  21 #include <linux/audit.h>
  22 #include <linux/pid_namespace.h>
  23 #include <linux/syscalls.h>
  24
  25 #include <asm/pgtable.h>
  26 #include <asm/uaccess.h>
  27
  28 /*
  29  * ptrace a task: make the debugger its new parent and
  30  * move it to the ptrace list.
  31  *
  32  * Must be called with the tasklist lock write-held.
  33  */
  34 void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
  35 {
  36         BUG_ON(!list_empty(&child->ptrace_entry));
  37         list_add(&child->ptrace_entry, &new_parent->ptraced);
  38         child->parent = new_parent;
  39 }
  40
  41 /*
  42  * Turn a tracing stop into a normal stop now, since with no tracer there
  43  * would be no way to wake it up with SIGCONT or SIGKILL.  If there was a
  44  * signal sent that would resume the child, but didn't because it was in
  45  * TASK_TRACED, resume it now.
  46  * Requires that irqs be disabled.
  47  */
  48 static void ptrace_untrace(struct task_struct *child)
  49 {
  50         spin_lock(&child->sighand->siglock);
  51         if (task_is_traced(child)) {
  52                 if (child->signal->flags & SIGNAL_STOP_STOPPED) {
  53                         __set_task_state(child, TASK_STOPPED);
  54                 } else {
  55                         signal_wake_up(child, 1);
  56                 }
  57         }
  58         spin_unlock(&child->sighand->siglock);
  59 }
  60
  61 /*
  62  * unptrace a task: move it back to its original parent and
  63  * remove it from the ptrace list.
  64  *
  65  * Must be called with the tasklist lock write-held.
  66  */
  67 void __ptrace_unlink(struct task_struct *child)
  68 {
  69         BUG_ON(!child->ptrace);
  70
  71         child->ptrace = 0;
  72         child->parent = child->real_parent;
  73         list_del_init(&child->ptrace_entry);
  74
  75         if (task_is_traced(child))
  76                 ptrace_untrace(child);
  77 }
  78
  79 /*
  80  * Check that we have indeed attached to the thing..
  81  */
  82 int ptrace_check_attach(struct task_struct *child, int kill)
  83 {
  84         int ret = -ESRCH;
  85
  86         /*
  87          * We take the read lock around doing both checks to close a
  88          * possible race where someone else was tracing our child and
  89          * detached between these two checks.  After this locked check,
  90          * we are sure that this is our traced child and that can only
  91          * be changed by us so it's not changing right after this.
  92          */
  93         read_lock(&tasklist_lock);
  94         if ((child->ptrace & PT_PTRACED) && child->parent == current) {
  95                 ret = 0;
  96                 /*
  97                  * child->sighand can't be NULL, release_task()
  98                  * does ptrace_unlink() before __exit_signal().
  99                  */
 100                 spin_lock_irq(&child->sighand->siglock);
 101                 if (task_is_stopped(child))
 102                         child->state = TASK_TRACED;
 103                 else if (!task_is_traced(child) && !kill)
 104                         ret = -ESRCH;
 105                 spin_unlock_irq(&child->sighand->siglock);
 106         }
 107         read_unlock(&tasklist_lock);
 108
 109         if (!ret && !kill)
 110                 ret = wait_task_inactive(child, TASK_TRACED) ? 0 : -ESRCH;
 111
 112         /* All systems go.. */
 113         return ret;
 114 }
 115
 116 int __ptrace_may_access(struct task_struct *task, unsigned int mode)
 117 {
 118         /* May we inspect the given task?
 119          * This check is used both for attaching with ptrace
 120          * and for allowing access to sensitive information in /proc.
 121          *
 122          * ptrace_attach denies several cases that /proc allows
 123          * because setting up the necessary parent/child relationship
 124          * or halting the specified task is impossible.
 125          */
 126         uid_t uid;
 127         gid_t gid;
 128         int dumpable = 0;
 129         /* Don't let security modules deny introspection */
 130         if (task == current)
 131                 return 0;
 132         current_uid_gid(&uid, &gid);
 133         if ((uid != task->euid ||
 134              uid != task->suid ||
 135              uid != task->uid  ||
 136              gid != task->egid ||
 137              gid != task->sgid ||
 138              gid != task->gid) && !capable(CAP_SYS_PTRACE))
 139                 return -EPERM;
 140         smp_rmb();
 141         if (task->mm)
 142                 dumpable = get_dumpable(task->mm);
 143         if (!dumpable && !capable(CAP_SYS_PTRACE))
 144                 return -EPERM;
 145
 146         return security_ptrace_may_access(task, mode);
 147 }
 148
 149 bool ptrace_may_access(struct task_struct *task, unsigned int mode)
 150 {
 151         int err;
 152         task_lock(task);
 153         err = __ptrace_may_access(task, mode);
 154         task_unlock(task);
 155         return (!err ? true : false);
 156 }
 157
 158 int ptrace_attach(struct task_struct *task)
 159 {
 160         int retval;
 161         unsigned long flags;
 162
 163         audit_ptrace(task);
 164
 165         retval = -EPERM;
 166         if (same_thread_group(task, current))
 167                 goto out;
 168
 169 repeat:
 170         /*
 171          * Nasty, nasty.
 172          *
 173          * We want to hold both the task-lock and the
 174          * tasklist_lock for writing at the same time.
 175          * But that's against the rules (tasklist_lock
 176          * is taken for reading by interrupts on other
 177          * cpu's that may have task_lock).
 178          */
 179         task_lock(task);
 180         if (!write_trylock_irqsave(&tasklist_lock, flags)) {
 181                 task_unlock(task);
 182                 do {
 183                         cpu_relax();
 184                 } while (!write_can_lock(&tasklist_lock));
 185                 goto repeat;
 186         }
 187
 188         if (!task->mm)
 189                 goto bad;
 190         /* the same process cannot be attached many times */
 191         if (task->ptrace & PT_PTRACED)
 192                 goto bad;
 193         retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH);
 194         if (retval)
 195                 goto bad;
 196
 197         /* Go */
 198         task->ptrace |= PT_PTRACED;
 199         if (capable(CAP_SYS_PTRACE))
 200                 task->ptrace |= PT_PTRACE_CAP;
 201
 202         __ptrace_link(task, current);
 203
 204         send_sig_info(SIGSTOP, SEND_SIG_FORCED, task);
 205 bad:
 206         write_unlock_irqrestore(&tasklist_lock, flags);
 207         task_unlock(task);
 208 out:
 209         return retval;
 210 }
 211
 212 static inline void __ptrace_detach(struct task_struct *child, unsigned int data)
 213 {
 214         child->exit_code = data;
 215         /* .. re-parent .. */
 216         __ptrace_unlink(child);
 217         /* .. and wake it up. */
 218         if (child->exit_state != EXIT_ZOMBIE)
 219                 wake_up_process(child);
 220 }
 221
 222 int ptrace_detach(struct task_struct *child, unsigned int data)
 223 {
 224         if (!valid_signal(data))
 225                 return -EIO;
 226
 227         /* Architecture-specific hardware disable .. */
 228         ptrace_disable(child);
 229         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 230
 231         write_lock_irq(&tasklist_lock);
 232         /* protect against de_thread()->release_task() */
 233         if (child->ptrace)
 234                 __ptrace_detach(child, data);
 235         write_unlock_irq(&tasklist_lock);
 236
 237         return 0;
 238 }
 239
 240 int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)
 241 {
 242         int copied = 0;
 243
 244         while (len > 0) {
 245                 char buf[128];
 246                 int this_len, retval;
 247
 248                 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
 249                 retval = access_process_vm(tsk, src, buf, this_len, 0);
 250                 if (!retval) {
 251                         if (copied)
 252                                 break;
 253                         return -EIO;
 254                 }
 255                 if (copy_to_user(dst, buf, retval))
 256                         return -EFAULT;
 257                 copied += retval;
 258                 src += retval;
 259                 dst += retval;
 260                 len -= retval;
 261         }
 262         return copied;
 263 }
 264
 265 int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)
 266 {
 267         int copied = 0;
 268
 269         while (len > 0) {
 270                 char buf[128];
 271                 int this_len, retval;
 272
 273                 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
 274                 if (copy_from_user(buf, src, this_len))
 275                         return -EFAULT;
 276                 retval = access_process_vm(tsk, dst, buf, this_len, 1);
 277                 if (!retval) {
 278                         if (copied)
 279                                 break;
 280                         return -EIO;
 281                 }
 282                 copied += retval;
 283                 src += retval;
 284                 dst += retval;
 285                 len -= retval;
 286         }
 287         return copied;
 288 }
 289
 290 static int ptrace_setoptions(struct task_struct *child, long data)
 291 {
 292         child->ptrace &= ~PT_TRACE_MASK;
 293
 294         if (data & PTRACE_O_TRACESYSGOOD)
 295                 child->ptrace |= PT_TRACESYSGOOD;
 296
 297         if (data & PTRACE_O_TRACEFORK)
 298                 child->ptrace |= PT_TRACE_FORK;
 299
 300         if (data & PTRACE_O_TRACEVFORK)
 301                 child->ptrace |= PT_TRACE_VFORK;
 302
 303         if (data & PTRACE_O_TRACECLONE)
 304                 child->ptrace |= PT_TRACE_CLONE;
 305
 306         if (data & PTRACE_O_TRACEEXEC)
 307                 child->ptrace |= PT_TRACE_EXEC;
 308
 309         if (data & PTRACE_O_TRACEVFORKDONE)
 310                 child->ptrace |= PT_TRACE_VFORK_DONE;
 311
 312         if (data & PTRACE_O_TRACEEXIT)
 313                 child->ptrace |= PT_TRACE_EXIT;
 314
 315         return (data & ~PTRACE_O_MASK) ? -EINVAL : 0;
 316 }
 317
 318 static int ptrace_getsiginfo(struct task_struct *child, siginfo_t *info)
 319 {
 320         int error = -ESRCH;
 321
 322         read_lock(&tasklist_lock);
 323         if (likely(child->sighand != NULL)) {
 324                 error = -EINVAL;
 325                 spin_lock_irq(&child->sighand->siglock);
 326                 if (likely(child->last_siginfo != NULL)) {
 327                         *info = *child->last_siginfo;
 328                         error = 0;
 329                 }
 330                 spin_unlock_irq(&child->sighand->siglock);
 331         }
 332         read_unlock(&tasklist_lock);
 333         return error;
 334 }
 335
 336 static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info)
 337 {
 338         int error = -ESRCH;
 339
 340         read_lock(&tasklist_lock);
 341         if (likely(child->sighand != NULL)) {
 342                 error = -EINVAL;
 343                 spin_lock_irq(&child->sighand->siglock);
 344                 if (likely(child->last_siginfo != NULL)) {
 345                         *child->last_siginfo = *info;
 346                         error = 0;
 347                 }
 348                 spin_unlock_irq(&child->sighand->siglock);
 349         }
 350         read_unlock(&tasklist_lock);
 351         return error;
 352 }
 353
 354
 355 #ifdef PTRACE_SINGLESTEP
 356 #define is_singlestep(request)          ((request) == PTRACE_SINGLESTEP)
 357 #else
 358 #define is_singlestep(request)          0
 359 #endif
 360
 361 #ifdef PTRACE_SINGLEBLOCK
 362 #define is_singleblock(request)         ((request) == PTRACE_SINGLEBLOCK)
 363 #else
 364 #define is_singleblock(request)         0
 365 #endif
 366
 367 #ifdef PTRACE_SYSEMU
 368 #define is_sysemu_singlestep(request)   ((request) == PTRACE_SYSEMU_SINGLESTEP)
 369 #else
 370 #define is_sysemu_singlestep(request)   0
 371 #endif
 372
 373 static int ptrace_resume(struct task_struct *child, long request, long data)
 374 {
 375         if (!valid_signal(data))
 376                 return -EIO;
 377
 378         if (request == PTRACE_SYSCALL)
 379                 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 380         else
 381                 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 382
 383 #ifdef TIF_SYSCALL_EMU
 384         if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP)
 385                 set_tsk_thread_flag(child, TIF_SYSCALL_EMU);
 386         else
 387                 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
 388 #endif
 389
 390         if (is_singleblock(request)) {
 391                 if (unlikely(!arch_has_block_step()))
 392                         return -EIO;
 393                 user_enable_block_step(child);
 394         } else if (is_singlestep(request) || is_sysemu_singlestep(request)) {
 395                 if (unlikely(!arch_has_single_step()))
 396                         return -EIO;
 397                 user_enable_single_step(child);
 398         }
 399         else
 400                 user_disable_single_step(child);
 401
 402         child->exit_code = data;
 403         wake_up_process(child);
 404
 405         return 0;
 406 }
 407
 408 int ptrace_request(struct task_struct *child, long request,
 409                    long addr, long data)
 410 {
 411         int ret = -EIO;
 412         siginfo_t siginfo;
 413
 414         switch (request) {
 415         case PTRACE_PEEKTEXT:
 416         case PTRACE_PEEKDATA:
 417                 return generic_ptrace_peekdata(child, addr, data);
 418         case PTRACE_POKETEXT:
 419         case PTRACE_POKEDATA:
 420                 return generic_ptrace_pokedata(child, addr, data);
 421
 422 #ifdef PTRACE_OLDSETOPTIONS
 423         case PTRACE_OLDSETOPTIONS:
 424 #endif
 425         case PTRACE_SETOPTIONS:
 426                 ret = ptrace_setoptions(child, data);
 427                 break;
 428         case PTRACE_GETEVENTMSG:
 429                 ret = put_user(child->ptrace_message, (unsigned long __user *) data);
 430                 break;
 431
 432         case PTRACE_GETSIGINFO:
 433                 ret = ptrace_getsiginfo(child, &siginfo);
 434                 if (!ret)
 435                         ret = copy_siginfo_to_user((siginfo_t __user *) data,
 436                                                    &siginfo);
 437                 break;
 438
 439         case PTRACE_SETSIGINFO:
 440                 if (copy_from_user(&siginfo, (siginfo_t __user *) data,
 441                                    sizeof siginfo))
 442                         ret = -EFAULT;
 443                 else
 444                         ret = ptrace_setsiginfo(child, &siginfo);
 445                 break;
 446
 447         case PTRACE_DETACH:      /* detach a process that was attached. */
 448                 ret = ptrace_detach(child, data);
 449                 break;
 450
 451 #ifdef PTRACE_SINGLESTEP
 452         case PTRACE_SINGLESTEP:
 453 #endif
 454 #ifdef PTRACE_SINGLEBLOCK
 455         case PTRACE_SINGLEBLOCK:
 456 #endif
 457 #ifdef PTRACE_SYSEMU
 458         case PTRACE_SYSEMU:
 459         case PTRACE_SYSEMU_SINGLESTEP:
 460 #endif
 461         case PTRACE_SYSCALL:
 462         case PTRACE_CONT:
 463                 return ptrace_resume(child, request, data);
 464
 465         case PTRACE_KILL:
 466                 if (child->exit_state)  /* already dead */
 467                         return 0;
 468                 return ptrace_resume(child, request, SIGKILL);
 469
 470         default:
 471                 break;
 472         }
 473
 474         return ret;
 475 }
 476
 477 /**
 478  * ptrace_traceme  --  helper for PTRACE_TRACEME
 479  *
 480  * Performs checks and sets PT_PTRACED.
 481  * Should be used by all ptrace implementations for PTRACE_TRACEME.
 482  */
 483 int ptrace_traceme(void)
 484 {
 485         int ret = -EPERM;
 486
 487         /*
 488          * Are we already being traced?
 489          */
 490 repeat:
 491         task_lock(current);
 492         if (!(current->ptrace & PT_PTRACED)) {
 493                 /*
 494                  * See ptrace_attach() comments about the locking here.
 495                  */
 496                 unsigned long flags;
 497                 if (!write_trylock_irqsave(&tasklist_lock, flags)) {
 498                         task_unlock(current);
 499                         do {
 500                                 cpu_relax();
 501                         } while (!write_can_lock(&tasklist_lock));
 502                         goto repeat;
 503                 }
 504
 505                 ret = security_ptrace_traceme(current->parent);
 506
 507                 /*
 508                  * Set the ptrace bit in the process ptrace flags.
 509                  * Then link us on our parent's ptraced list.
 510                  */
 511                 if (!ret) {
 512                         current->ptrace |= PT_PTRACED;
 513                         __ptrace_link(current, current->real_parent);
 514                 }
 515
 516                 write_unlock_irqrestore(&tasklist_lock, flags);
 517         }
 518         task_unlock(current);
 519         return ret;
 520 }
 521
 522 /**
 523  * ptrace_get_task_struct  --  grab a task struct reference for ptrace
 524  * @pid:       process id to grab a task_struct reference of
 525  *
 526  * This function is a helper for ptrace implementations.  It checks
 527  * permissions and then grabs a task struct for use of the actual
 528  * ptrace implementation.
 529  *
 530  * Returns the task_struct for @pid or an ERR_PTR() on failure.
 531  */
 532 struct task_struct *ptrace_get_task_struct(pid_t pid)
 533 {
 534         struct task_struct *child;
 535
 536         read_lock(&tasklist_lock);
 537         child = find_task_by_vpid(pid);
 538         if (child)
 539                 get_task_struct(child);
 540
 541         read_unlock(&tasklist_lock);
 542         if (!child)
 543                 return ERR_PTR(-ESRCH);
 544         return child;
 545 }
 546
 547 #ifndef arch_ptrace_attach
 548 #define arch_ptrace_attach(child)       do { } while (0)
 549 #endif
 550
 551 asmlinkage long sys_ptrace(long request, long pid, long addr, long data)
 552 {
 553         struct task_struct *child;
 554         long ret;
 555
 556         /*
 557          * This lock_kernel fixes a subtle race with suid exec
 558          */
 559         lock_kernel();
 560         if (request == PTRACE_TRACEME) {
 561                 ret = ptrace_traceme();
 562                 if (!ret)
 563                         arch_ptrace_attach(current);
 564                 goto out;
 565         }
 566
 567         child = ptrace_get_task_struct(pid);
 568         if (IS_ERR(child)) {
 569                 ret = PTR_ERR(child);
 570                 goto out;
 571         }
 572
 573         if (request == PTRACE_ATTACH) {
 574                 ret = ptrace_attach(child);
 575                 /*
 576                  * Some architectures need to do book-keeping after
 577                  * a ptrace attach.
 578                  */
 579                 if (!ret)
 580                         arch_ptrace_attach(child);
 581                 goto out_put_task_struct;
 582         }
 583
 584         ret = ptrace_check_attach(child, request == PTRACE_KILL);
 585         if (ret < 0)
 586                 goto out_put_task_struct;
 587
 588         ret = arch_ptrace(child, request, addr, data);
 589         if (ret < 0)
 590                 goto out_put_task_struct;
 591
 592  out_put_task_struct:
 593         put_task_struct(child);
 594  out:
 595         unlock_kernel();
 596         return ret;
 597 }
 598
 599 int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data)
 600 {
 601         unsigned long tmp;
 602         int copied;
 603
 604         copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0);
 605         if (copied != sizeof(tmp))
 606                 return -EIO;
 607         return put_user(tmp, (unsigned long __user *)data);
 608 }
 609
 610 int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data)
 611 {
 612         int copied;
 613
 614         copied = access_process_vm(tsk, addr, &data, sizeof(data), 1);
 615         return (copied == sizeof(data)) ? 0 : -EIO;
 616 }
 617
 618 #if defined CONFIG_COMPAT && defined __ARCH_WANT_COMPAT_SYS_PTRACE
 619 #include <linux/compat.h>
 620
 621 int compat_ptrace_request(struct task_struct *child, compat_long_t request,
 622                           compat_ulong_t addr, compat_ulong_t data)
 623 {
 624         compat_ulong_t __user *datap = compat_ptr(data);
 625         compat_ulong_t word;
 626         siginfo_t siginfo;
 627         int ret;
 628
 629         switch (request) {
 630         case PTRACE_PEEKTEXT:
 631         case PTRACE_PEEKDATA:
 632                 ret = access_process_vm(child, addr, &word, sizeof(word), 0);
 633                 if (ret != sizeof(word))
 634                         ret = -EIO;
 635                 else
 636                         ret = put_user(word, datap);
 637                 break;
 638
 639         case PTRACE_POKETEXT:
 640         case PTRACE_POKEDATA:
 641                 ret = access_process_vm(child, addr, &data, sizeof(data), 1);
 642                 ret = (ret != sizeof(data) ? -EIO : 0);
 643                 break;
 644
 645         case PTRACE_GETEVENTMSG:
 646                 ret = put_user((compat_ulong_t) child->ptrace_message, datap);
 647                 break;
 648
 649         case PTRACE_GETSIGINFO:
 650                 ret = ptrace_getsiginfo(child, &siginfo);
 651                 if (!ret)
 652                         ret = copy_siginfo_to_user32(
 653                                 (struct compat_siginfo __user *) datap,
 654                                 &siginfo);
 655                 break;
 656
 657         case PTRACE_SETSIGINFO:
 658                 memset(&siginfo, 0, sizeof siginfo);
 659                 if (copy_siginfo_from_user32(
 660                             &siginfo, (struct compat_siginfo __user *) datap))
 661                         ret = -EFAULT;
 662                 else
 663                         ret = ptrace_setsiginfo(child, &siginfo);
 664                 break;
 665
 666         default:
 667                 ret = ptrace_request(child, request, addr, data);
 668         }
 669
 670         return ret;
 671 }
 672
 673 asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
 674                                   compat_long_t addr, compat_long_t data)
 675 {
 676         struct task_struct *child;
 677         long ret;
 678
 679         /*
 680          * This lock_kernel fixes a subtle race with suid exec
 681          */
 682         lock_kernel();
 683         if (request == PTRACE_TRACEME) {
 684                 ret = ptrace_traceme();
 685                 goto out;
 686         }
 687
 688         child = ptrace_get_task_struct(pid);
 689         if (IS_ERR(child)) {
 690                 ret = PTR_ERR(child);
 691                 goto out;
 692         }
 693
 694         if (request == PTRACE_ATTACH) {
 695                 ret = ptrace_attach(child);
 696                 /*
 697                  * Some architectures need to do book-keeping after
 698                  * a ptrace attach.
 699                  */
 700                 if (!ret)
 701                         arch_ptrace_attach(child);
 702                 goto out_put_task_struct;
 703         }
 704
 705         ret = ptrace_check_attach(child, request == PTRACE_KILL);
 706         if (!ret)
 707                 ret = compat_arch_ptrace(child, request, addr, data);
 708
 709  out_put_task_struct:
 710         put_task_struct(child);
 711  out:
 712         unlock_kernel();
 713         return ret;
 714 }
 715 #endif  /* CONFIG_COMPAT && __ARCH_WANT_COMPAT_SYS_PTRACE */