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/vs_cvirt.h>
  22
  23 #include <asm/pgtable.h>
  24 #include <asm/uaccess.h>
  25
  26 /*
  27  * ptrace a task: make the debugger its new parent and
  28  * move it to the ptrace list.
  29  *
  30  * Must be called with the tasklist lock write-held.
  31  */
  32 void __ptrace_link(task_t *child, task_t *new_parent)
  33 {
  34         if (!list_empty(&child->ptrace_list))
  35                 BUG();
  36         if (child->parent == new_parent)
  37                 return;
  38         list_add(&child->ptrace_list, &child->parent->ptrace_children);
  39         REMOVE_LINKS(child);
  40         child->parent = new_parent;
  41         SET_LINKS(child);
  42 }
  43
  44 /*
  45  * Turn a tracing stop into a normal stop now, since with no tracer there
  46  * would be no way to wake it up with SIGCONT or SIGKILL.  If there was a
  47  * signal sent that would resume the child, but didn't because it was in
  48  * TASK_TRACED, resume it now.
  49  * Requires that irqs be disabled.
  50  */
  51 void ptrace_untrace(task_t *child)
  52 {
  53         spin_lock(&child->sighand->siglock);
  54         if (child->state == TASK_TRACED) {
  55                 if (child->signal->flags & SIGNAL_STOP_STOPPED) {
  56                         child->state = TASK_STOPPED;
  57                 } else {
  58                         signal_wake_up(child, 1);
  59                 }
  60         }
  61         spin_unlock(&child->sighand->siglock);
  62 }
  63
  64 /*
  65  * unptrace a task: move it back to its original parent and
  66  * remove it from the ptrace list.
  67  *
  68  * Must be called with the tasklist lock write-held.
  69  */
  70 void __ptrace_unlink(task_t *child)
  71 {
  72         BUG_ON(!child->ptrace);
  73
  74         child->ptrace = 0;
  75         if (!list_empty(&child->ptrace_list)) {
  76                 list_del_init(&child->ptrace_list);
  77                 REMOVE_LINKS(child);
  78                 child->parent = child->real_parent;
  79                 SET_LINKS(child);
  80         }
  81
  82         if (child->state == TASK_TRACED)
  83                 ptrace_untrace(child);
  84 }
  85
  86 /*
  87  * Check that we have indeed attached to the thing..
  88  */
  89 int ptrace_check_attach(struct task_struct *child, int kill)
  90 {
  91         int ret = -ESRCH;
  92
  93         /*
  94          * We take the read lock around doing both checks to close a
  95          * possible race where someone else was tracing our child and
  96          * detached between these two checks.  After this locked check,
  97          * we are sure that this is our traced child and that can only
  98          * be changed by us so it's not changing right after this.
  99          */
 100         read_lock(&tasklist_lock);
 101         if ((child->ptrace & PT_PTRACED) && child->parent == current &&
 102             (!(child->ptrace & PT_ATTACHED) || child->real_parent != current)
 103             && child->signal != NULL) {
 104                 ret = 0;
 105                 spin_lock_irq(&child->sighand->siglock);
 106                 if (child->state == TASK_STOPPED) {
 107                         child->state = TASK_TRACED;
 108                 } else if (child->state != TASK_TRACED && !kill) {
 109                         ret = -ESRCH;
 110                 }
 111                 spin_unlock_irq(&child->sighand->siglock);
 112         }
 113         read_unlock(&tasklist_lock);
 114
 115         /* All systems go.. */
 116         return ret;
 117 }
 118
 119 static int may_attach(struct task_struct *task)
 120 {
 121         if (!task->mm)
 122                 return -EPERM;
 123         if (((current->uid != task->euid) ||
 124              (current->uid != task->suid) ||
 125              (current->uid != task->uid) ||
 126              (current->gid != task->egid) ||
 127              (current->gid != task->sgid) ||
 128              (current->gid != task->gid)) && !capable(CAP_SYS_PTRACE))
 129                 return -EPERM;
 130         smp_rmb();
 131         if (!task->mm->dumpable && !capable(CAP_SYS_PTRACE))
 132                 return -EPERM;
 133
 134         return security_ptrace(current, task);
 135 }
 136
 137 int ptrace_may_attach(struct task_struct *task)
 138 {
 139         int err;
 140         task_lock(task);
 141         err = may_attach(task);
 142         task_unlock(task);
 143         return !err;
 144 }
 145
 146 int ptrace_attach(struct task_struct *task)
 147 {
 148         int retval;
 149
 150         retval = -EPERM;
 151         if (task->pid <= 1)
 152                 goto out;
 153         if (task->tgid == current->tgid)
 154                 goto out;
 155
 156 repeat:
 157         /*
 158          * Nasty, nasty.
 159          *
 160          * We want to hold both the task-lock and the
 161          * tasklist_lock for writing at the same time.
 162          * But that's against the rules (tasklist_lock
 163          * is taken for reading by interrupts on other
 164          * cpu's that may have task_lock).
 165          */
 166         task_lock(task);
 167         local_irq_disable();
 168         if (!write_trylock(&tasklist_lock)) {
 169                 local_irq_enable();
 170                 task_unlock(task);
 171                 do {
 172                         cpu_relax();
 173                 } while (!write_can_lock(&tasklist_lock));
 174                 goto repeat;
 175         }
 176
 177         /* the same process cannot be attached many times */
 178         if (task->ptrace & PT_PTRACED)
 179                 goto bad;
 180         retval = may_attach(task);
 181         if (retval)
 182                 goto bad;
 183
 184         /* Go */
 185         task->ptrace |= PT_PTRACED | ((task->real_parent != current)
 186                                       ? PT_ATTACHED : 0);
 187         if (capable(CAP_SYS_PTRACE))
 188                 task->ptrace |= PT_PTRACE_CAP;
 189
 190         __ptrace_link(task, current);
 191
 192         force_sig_specific(SIGSTOP, task);
 193
 194 bad:
 195         write_unlock_irq(&tasklist_lock);
 196         task_unlock(task);
 197 out:
 198         return retval;
 199 }
 200
 201 void __ptrace_detach(struct task_struct *child, unsigned int data)
 202 {
 203         child->exit_code = data;
 204         /* .. re-parent .. */
 205         __ptrace_unlink(child);
 206         /* .. and wake it up. */
 207         if (child->exit_state != EXIT_ZOMBIE)
 208                 wake_up_process(child);
 209 }
 210
 211 int ptrace_detach(struct task_struct *child, unsigned int data)
 212 {
 213         if (!valid_signal(data))
 214                 return -EIO;
 215
 216         /* Architecture-specific hardware disable .. */
 217         ptrace_disable(child);
 218
 219         write_lock_irq(&tasklist_lock);
 220         if (child->ptrace)
 221                 __ptrace_detach(child, data);
 222         write_unlock_irq(&tasklist_lock);
 223
 224         return 0;
 225 }
 226
 227 /*
 228  * Access another process' address space.
 229  * Source/target buffer must be kernel space,
 230  * Do not walk the page table directly, use get_user_pages
 231  */
 232
 233 int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write)
 234 {
 235         struct mm_struct *mm;
 236         struct vm_area_struct *vma;
 237         struct page *page;
 238         void *old_buf = buf;
 239
 240         mm = get_task_mm(tsk);
 241         if (!mm)
 242                 return 0;
 243
 244         down_read(&mm->mmap_sem);
 245         /* ignore errors, just check how much was sucessfully transfered */
 246         while (len) {
 247                 int bytes, ret, offset;
 248                 void *maddr;
 249
 250                 ret = get_user_pages(tsk, mm, addr, 1,
 251                                 write, 1, &page, &vma);
 252                 if (ret <= 0)
 253                         break;
 254
 255                 bytes = len;
 256                 offset = addr & (PAGE_SIZE-1);
 257                 if (bytes > PAGE_SIZE-offset)
 258                         bytes = PAGE_SIZE-offset;
 259
 260                 maddr = kmap(page);
 261                 if (write) {
 262                         copy_to_user_page(vma, page, addr,
 263                                           maddr + offset, buf, bytes);
 264                         set_page_dirty_lock(page);
 265                 } else {
 266                         copy_from_user_page(vma, page, addr,
 267                                             buf, maddr + offset, bytes);
 268                 }
 269                 kunmap(page);
 270                 page_cache_release(page);
 271                 len -= bytes;
 272                 buf += bytes;
 273                 addr += bytes;
 274         }
 275         up_read(&mm->mmap_sem);
 276         mmput(mm);
 277
 278         return buf - old_buf;
 279 }
 280
 281 int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)
 282 {
 283         int copied = 0;
 284
 285         while (len > 0) {
 286                 char buf[128];
 287                 int this_len, retval;
 288
 289                 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
 290                 retval = access_process_vm(tsk, src, buf, this_len, 0);
 291                 if (!retval) {
 292                         if (copied)
 293                                 break;
 294                         return -EIO;
 295                 }
 296                 if (copy_to_user(dst, buf, retval))
 297                         return -EFAULT;
 298                 copied += retval;
 299                 src += retval;
 300                 dst += retval;
 301                 len -= retval;
 302         }
 303         return copied;
 304 }
 305
 306 int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)
 307 {
 308         int copied = 0;
 309
 310         while (len > 0) {
 311                 char buf[128];
 312                 int this_len, retval;
 313
 314                 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
 315                 if (copy_from_user(buf, src, this_len))
 316                         return -EFAULT;
 317                 retval = access_process_vm(tsk, dst, buf, this_len, 1);
 318                 if (!retval) {
 319                         if (copied)
 320                                 break;
 321                         return -EIO;
 322                 }
 323                 copied += retval;
 324                 src += retval;
 325                 dst += retval;
 326                 len -= retval;
 327         }
 328         return copied;
 329 }
 330
 331 static int ptrace_setoptions(struct task_struct *child, long data)
 332 {
 333         child->ptrace &= ~PT_TRACE_MASK;
 334
 335         if (data & PTRACE_O_TRACESYSGOOD)
 336                 child->ptrace |= PT_TRACESYSGOOD;
 337
 338         if (data & PTRACE_O_TRACEFORK)
 339                 child->ptrace |= PT_TRACE_FORK;
 340
 341         if (data & PTRACE_O_TRACEVFORK)
 342                 child->ptrace |= PT_TRACE_VFORK;
 343
 344         if (data & PTRACE_O_TRACECLONE)
 345                 child->ptrace |= PT_TRACE_CLONE;
 346
 347         if (data & PTRACE_O_TRACEEXEC)
 348                 child->ptrace |= PT_TRACE_EXEC;
 349
 350         if (data & PTRACE_O_TRACEVFORKDONE)
 351                 child->ptrace |= PT_TRACE_VFORK_DONE;
 352
 353         if (data & PTRACE_O_TRACEEXIT)
 354                 child->ptrace |= PT_TRACE_EXIT;
 355
 356         return (data & ~PTRACE_O_MASK) ? -EINVAL : 0;
 357 }
 358
 359 static int ptrace_getsiginfo(struct task_struct *child, siginfo_t __user * data)
 360 {
 361         siginfo_t lastinfo;
 362         int error = -ESRCH;
 363
 364         read_lock(&tasklist_lock);
 365         if (likely(child->sighand != NULL)) {
 366                 error = -EINVAL;
 367                 spin_lock_irq(&child->sighand->siglock);
 368                 if (likely(child->last_siginfo != NULL)) {
 369                         lastinfo = *child->last_siginfo;
 370                         error = 0;
 371                 }
 372                 spin_unlock_irq(&child->sighand->siglock);
 373         }
 374         read_unlock(&tasklist_lock);
 375         if (!error)
 376                 return copy_siginfo_to_user(data, &lastinfo);
 377         return error;
 378 }
 379
 380 static int ptrace_setsiginfo(struct task_struct *child, siginfo_t __user * data)
 381 {
 382         siginfo_t newinfo;
 383         int error = -ESRCH;
 384
 385         if (copy_from_user(&newinfo, data, sizeof (siginfo_t)))
 386                 return -EFAULT;
 387
 388         read_lock(&tasklist_lock);
 389         if (likely(child->sighand != NULL)) {
 390                 error = -EINVAL;
 391                 spin_lock_irq(&child->sighand->siglock);
 392                 if (likely(child->last_siginfo != NULL)) {
 393                         *child->last_siginfo = newinfo;
 394                         error = 0;
 395                 }
 396                 spin_unlock_irq(&child->sighand->siglock);
 397         }
 398         read_unlock(&tasklist_lock);
 399         return error;
 400 }
 401
 402 int ptrace_request(struct task_struct *child, long request,
 403                    long addr, long data)
 404 {
 405         int ret = -EIO;
 406
 407         switch (request) {
 408 #ifdef PTRACE_OLDSETOPTIONS
 409         case PTRACE_OLDSETOPTIONS:
 410 #endif
 411         case PTRACE_SETOPTIONS:
 412                 ret = ptrace_setoptions(child, data);
 413                 break;
 414         case PTRACE_GETEVENTMSG:
 415                 ret = put_user(child->ptrace_message, (unsigned long __user *) data);
 416                 break;
 417         case PTRACE_GETSIGINFO:
 418                 ret = ptrace_getsiginfo(child, (siginfo_t __user *) data);
 419                 break;
 420         case PTRACE_SETSIGINFO:
 421                 ret = ptrace_setsiginfo(child, (siginfo_t __user *) data);
 422                 break;
 423         default:
 424                 break;
 425         }
 426
 427         return ret;
 428 }
 429
 430 /**
 431  * ptrace_traceme  --  helper for PTRACE_TRACEME
 432  *
 433  * Performs checks and sets PT_PTRACED.
 434  * Should be used by all ptrace implementations for PTRACE_TRACEME.
 435  */
 436 int ptrace_traceme(void)
 437 {
 438         int ret = -EPERM;
 439
 440         /*
 441          * Are we already being traced?
 442          */
 443         task_lock(current);
 444         if (!(current->ptrace & PT_PTRACED)) {
 445                 ret = security_ptrace(current->parent, current);
 446                 /*
 447                  * Set the ptrace bit in the process ptrace flags.
 448                  */
 449                 if (!ret)
 450                         current->ptrace |= PT_PTRACED;
 451         }
 452         task_unlock(current);
 453         return ret;
 454 }
 455
 456 /**
 457  * ptrace_get_task_struct  --  grab a task struct reference for ptrace
 458  * @pid:       process id to grab a task_struct reference of
 459  *
 460  * This function is a helper for ptrace implementations.  It checks
 461  * permissions and then grabs a task struct for use of the actual
 462  * ptrace implementation.
 463  *
 464  * Returns the task_struct for @pid or an ERR_PTR() on failure.
 465  */
 466 struct task_struct *ptrace_get_task_struct(pid_t pid)
 467 {
 468         struct task_struct *child;
 469
 470         /*
 471          * Tracing init is not allowed.
 472          */
 473         if (pid == 1)
 474                 return ERR_PTR(-EPERM);
 475
 476         read_lock(&tasklist_lock);
 477         child = find_task_by_pid(pid);
 478         if (child)
 479                 get_task_struct(child);
 480         read_unlock(&tasklist_lock);
 481         if (!child)
 482                 return ERR_PTR(-ESRCH);
 483         return child;
 484 }
 485
 486 #ifndef __ARCH_SYS_PTRACE
 487 asmlinkage long sys_ptrace(long request, long pid, long addr, long data)
 488 {
 489         struct task_struct *child;
 490         long ret;
 491
 492         /*
 493          * This lock_kernel fixes a subtle race with suid exec
 494          */
 495         lock_kernel();
 496         if (request == PTRACE_TRACEME) {
 497                 ret = ptrace_traceme();
 498                 goto out;
 499         }
 500
 501         child = ptrace_get_task_struct(pid);
 502         if (IS_ERR(child)) {
 503                 ret = PTR_ERR(child);
 504                 goto out;
 505         }
 506
 507         ret = -EPERM;
 508         if (!vx_check(vx_task_xid(child), VX_WATCH|VX_IDENT))
 509                 goto out_put_task_struct;
 510
 511         if (request == PTRACE_ATTACH) {
 512                 ret = ptrace_attach(child);
 513                 goto out_put_task_struct;
 514         }
 515
 516         ret = ptrace_check_attach(child, request == PTRACE_KILL);
 517         if (ret < 0)
 518                 goto out_put_task_struct;
 519
 520         ret = arch_ptrace(child, request, addr, data);
 521         if (ret < 0)
 522                 goto out_put_task_struct;
 523
 524  out_put_task_struct:
 525         put_task_struct(child);
 526  out:
 527         unlock_kernel();
 528         return ret;
 529 }
 530 #endif /* __ARCH_SYS_PTRACE */