sys/kern/kern_ktrace.c

   1 /*
   2  * Copyright (c) 1989, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  *      @(#)kern_ktrace.c       8.2 (Berkeley) 9/23/93
  34  * $FreeBSD: src/sys/kern/kern_ktrace.c,v 1.35.2.6 2002/07/05 22:36:38 darrenr Exp $
  35  * $DragonFly: src/sys/kern/kern_ktrace.c,v 1.15 2004/05/21 15:41:23 drhodus Exp $
  36  */
  37
  38 #include "opt_ktrace.h"
  39
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/sysproto.h>
  43 #include <sys/kernel.h>
  44 #include <sys/proc.h>
  45 #include <sys/fcntl.h>
  46 #include <sys/lock.h>
  47 #include <sys/namei.h>
  48 #include <sys/vnode.h>
  49 #include <sys/ktrace.h>
  50 #include <sys/malloc.h>
  51 #include <sys/syslog.h>
  52 #include <sys/sysent.h>
  53
  54 #include <vm/vm_zone.h>
  55 static MALLOC_DEFINE(M_KTRACE, "KTRACE", "KTRACE");
  56
  57 #ifdef KTRACE
  58 static struct ktr_header *ktrgetheader (int type);
  59 static void ktrwrite (struct vnode *, struct ktr_header *, struct uio *);
  60 static int ktrcanset (struct proc *,struct proc *);
  61 static int ktrsetchildren (struct proc *,struct proc *,int,int,struct vnode *);
  62 static int ktrops (struct proc *,struct proc *,int,int,struct vnode *);
  63
  64
  65 static struct ktr_header *
  66 ktrgetheader(int type)
  67 {
  68         struct ktr_header *kth;
  69         struct proc *p = curproc;       /* XXX */
  70
  71         MALLOC(kth, struct ktr_header *, sizeof (struct ktr_header),
  72                 M_KTRACE, M_WAITOK);
  73         kth->ktr_type = type;
  74         microtime(&kth->ktr_time);
  75         kth->ktr_pid = p->p_pid;
  76         bcopy(p->p_comm, kth->ktr_comm, MAXCOMLEN + 1);
  77         return (kth);
  78 }
  79
  80 void
  81 ktrsyscall(struct vnode *vp, int code, int narg, register_t args[])
  82 {
  83         struct  ktr_header *kth;
  84         struct  ktr_syscall *ktp;
  85         int len = offsetof(struct ktr_syscall, ktr_args) +
  86             (narg * sizeof(register_t));
  87         struct proc *p = curproc;       /* XXX */
  88         register_t *argp;
  89         int i;
  90
  91         p->p_traceflag |= KTRFAC_ACTIVE;
  92         kth = ktrgetheader(KTR_SYSCALL);
  93         MALLOC(ktp, struct ktr_syscall *, len, M_KTRACE, M_WAITOK);
  94         ktp->ktr_code = code;
  95         ktp->ktr_narg = narg;
  96         argp = &ktp->ktr_args[0];
  97         for (i = 0; i < narg; i++)
  98                 *argp++ = args[i];
  99         kth->ktr_buf = (caddr_t)ktp;
 100         kth->ktr_len = len;
 101         ktrwrite(vp, kth, NULL);
 102         FREE(ktp, M_KTRACE);
 103         FREE(kth, M_KTRACE);
 104         p->p_traceflag &= ~KTRFAC_ACTIVE;
 105 }
 106
 107 void
 108 ktrsysret(struct vnode *vp, int code, int error, register_t retval)
 109 {
 110         struct ktr_header *kth;
 111         struct ktr_sysret ktp;
 112         struct proc *p = curproc;       /* XXX */
 113
 114         p->p_traceflag |= KTRFAC_ACTIVE;
 115         kth = ktrgetheader(KTR_SYSRET);
 116         ktp.ktr_code = code;
 117         ktp.ktr_error = error;
 118         ktp.ktr_retval = retval;                /* what about val2 ? */
 119
 120         kth->ktr_buf = (caddr_t)&ktp;
 121         kth->ktr_len = sizeof(struct ktr_sysret);
 122
 123         ktrwrite(vp, kth, NULL);
 124         FREE(kth, M_KTRACE);
 125         p->p_traceflag &= ~KTRFAC_ACTIVE;
 126 }
 127
 128 void
 129 ktrnamei(struct vnode *vp, char *path)
 130 {
 131         struct ktr_header *kth;
 132         struct proc *p = curproc;       /* XXX */
 133
 134         /*
 135          * don't let vp get ripped out from under us
 136          */
 137         if (vp)
 138                 vref(vp);
 139         p->p_traceflag |= KTRFAC_ACTIVE;
 140         kth = ktrgetheader(KTR_NAMEI);
 141         kth->ktr_len = strlen(path);
 142         kth->ktr_buf = path;
 143
 144         ktrwrite(vp, kth, NULL);
 145         if (vp)
 146                 vrele(vp);
 147         FREE(kth, M_KTRACE);
 148         p->p_traceflag &= ~KTRFAC_ACTIVE;
 149 }
 150
 151 void
 152 ktrgenio(struct vnode *vp, int fd, enum uio_rw rw, struct uio *uio, int error)
 153 {
 154         struct ktr_header *kth;
 155         struct ktr_genio ktg;
 156         struct proc *p = curproc;       /* XXX */
 157
 158         if (error)
 159                 return;
 160         /*
 161          * don't let p_tracep get ripped out from under us
 162          */
 163         if (vp)
 164                 vref(vp);
 165         p->p_traceflag |= KTRFAC_ACTIVE;
 166         kth = ktrgetheader(KTR_GENIO);
 167         ktg.ktr_fd = fd;
 168         ktg.ktr_rw = rw;
 169         kth->ktr_buf = (caddr_t)&ktg;
 170         kth->ktr_len = sizeof(struct ktr_genio);
 171         uio->uio_offset = 0;
 172         uio->uio_rw = UIO_WRITE;
 173
 174         ktrwrite(vp, kth, uio);
 175         if (vp)
 176                 vrele(vp);
 177         FREE(kth, M_KTRACE);
 178         p->p_traceflag &= ~KTRFAC_ACTIVE;
 179 }
 180
 181 void
 182 ktrpsig(struct vnode *vp, int sig, sig_t action, sigset_t *mask, int code)
 183 {
 184         struct ktr_header *kth;
 185         struct ktr_psig kp;
 186         struct proc *p = curproc;       /* XXX */
 187
 188         /*
 189          * don't let vp get ripped out from under us
 190          */
 191         if (vp)
 192                 vref(vp);
 193         p->p_traceflag |= KTRFAC_ACTIVE;
 194         kth = ktrgetheader(KTR_PSIG);
 195         kp.signo = (char)sig;
 196         kp.action = action;
 197         kp.mask = *mask;
 198         kp.code = code;
 199         kth->ktr_buf = (caddr_t)&kp;
 200         kth->ktr_len = sizeof (struct ktr_psig);
 201
 202         ktrwrite(vp, kth, NULL);
 203         if (vp)
 204                 vrele(vp);
 205         FREE(kth, M_KTRACE);
 206         p->p_traceflag &= ~KTRFAC_ACTIVE;
 207 }
 208
 209 void
 210 ktrcsw(struct vnode *vp, int out, int user)
 211 {
 212         struct ktr_header *kth;
 213         struct  ktr_csw kc;
 214         struct proc *p = curproc;       /* XXX */
 215
 216         /*
 217          * don't let vp get ripped out from under us
 218          */
 219         if (vp)
 220                 vref(vp);
 221         p->p_traceflag |= KTRFAC_ACTIVE;
 222         kth = ktrgetheader(KTR_CSW);
 223         kc.out = out;
 224         kc.user = user;
 225         kth->ktr_buf = (caddr_t)&kc;
 226         kth->ktr_len = sizeof (struct ktr_csw);
 227
 228         ktrwrite(vp, kth, NULL);
 229         if (vp)
 230                 vrele(vp);
 231         FREE(kth, M_KTRACE);
 232         p->p_traceflag &= ~KTRFAC_ACTIVE;
 233 }
 234 #endif
 235
 236 /* Interface and common routines */
 237
 238 /*
 239  * ktrace system call
 240  */
 241 /* ARGSUSED */
 242 int
 243 ktrace(struct ktrace_args *uap)
 244 {
 245 #ifdef KTRACE
 246         struct thread *td = curthread;
 247         struct proc *curp = td->td_proc;
 248         struct vnode *vp = NULL;
 249         struct proc *p;
 250         struct pgrp *pg;
 251         int facs = uap->facs & ~KTRFAC_ROOT;
 252         int ops = KTROP(uap->ops);
 253         int descend = uap->ops & KTRFLAG_DESCEND;
 254         int ret = 0;
 255         int error = 0;
 256         struct nameidata nd;
 257
 258         curp->p_traceflag |= KTRFAC_ACTIVE;
 259         if (ops != KTROP_CLEAR) {
 260                 /*
 261                  * an operation which requires a file argument.
 262                  */
 263                 NDINIT(&nd, NAMEI_LOOKUP, 0, UIO_USERSPACE, uap->fname, td);
 264                 error = vn_open(&nd, FREAD|FWRITE|O_NOFOLLOW, 0);
 265                 if (error) {
 266                         curp->p_traceflag &= ~KTRFAC_ACTIVE;
 267                         return (error);
 268                 }
 269                 NDFREE(&nd, NDF_ONLY_PNBUF);
 270                 vp = nd.ni_vp;
 271                 VOP_UNLOCK(vp, NULL, 0, td);
 272                 if (vp->v_type != VREG) {
 273                         (void) vn_close(vp, FREAD|FWRITE, td);
 274                         curp->p_traceflag &= ~KTRFAC_ACTIVE;
 275                         return (EACCES);
 276                 }
 277         }
 278         /*
 279          * Clear all uses of the tracefile.  XXX umm, what happens to the
 280          * loop if vn_close() blocks?
 281          */
 282         if (ops == KTROP_CLEARFILE) {
 283                 FOREACH_PROC_IN_SYSTEM(p) {
 284                         if (p->p_tracep == vp) {
 285                                 if (ktrcanset(curp, p) && p->p_tracep == vp) {
 286                                         p->p_tracep = NULL;
 287                                         p->p_traceflag = 0;
 288                                         (void) vn_close(vp, FREAD|FWRITE, td);
 289                                 } else {
 290                                         error = EPERM;
 291                                 }
 292                         }
 293                 }
 294                 goto done;
 295         }
 296         /*
 297          * need something to (un)trace (XXX - why is this here?)
 298          */
 299         if (!facs) {
 300                 error = EINVAL;
 301                 goto done;
 302         }
 303         /*
 304          * do it
 305          */
 306         if (uap->pid < 0) {
 307                 /*
 308                  * by process group
 309                  */
 310                 pg = pgfind(-uap->pid);
 311                 if (pg == NULL) {
 312                         error = ESRCH;
 313                         goto done;
 314                 }
 315                 LIST_FOREACH(p, &pg->pg_members, p_pglist)
 316                         if (descend)
 317                                 ret |= ktrsetchildren(curp, p, ops, facs, vp);
 318                         else
 319                                 ret |= ktrops(curp, p, ops, facs, vp);
 320
 321         } else {
 322                 /*
 323                  * by pid
 324                  */
 325                 p = pfind(uap->pid);
 326                 if (p == NULL) {
 327                         error = ESRCH;
 328                         goto done;
 329                 }
 330                 if (descend)
 331                         ret |= ktrsetchildren(curp, p, ops, facs, vp);
 332                 else
 333                         ret |= ktrops(curp, p, ops, facs, vp);
 334         }
 335         if (!ret)
 336                 error = EPERM;
 337 done:
 338         if (vp != NULL)
 339                 (void) vn_close(vp, FWRITE, td);
 340         curp->p_traceflag &= ~KTRFAC_ACTIVE;
 341         return (error);
 342 #else
 343         return ENOSYS;
 344 #endif
 345 }
 346
 347 /*
 348  * utrace system call
 349  */
 350 /* ARGSUSED */
 351 int
 352 utrace(struct utrace_args *uap)
 353 {
 354 #ifdef KTRACE
 355         struct ktr_header *kth;
 356         struct thread *td = curthread;  /* XXX */
 357         struct proc *p = td->td_proc;
 358         struct vnode *vp;
 359         caddr_t cp;
 360
 361         if (!KTRPOINT(td, KTR_USER))
 362                 return (0);
 363         if (SCARG(uap, len) > KTR_USER_MAXLEN)
 364                 return (EINVAL);
 365         p->p_traceflag |= KTRFAC_ACTIVE;
 366         /*
 367          * don't let p_tracep get ripped out from under us while we are
 368          * writing.
 369          */
 370         if ((vp = p->p_tracep) != NULL)
 371                 vref(vp);
 372         kth = ktrgetheader(KTR_USER);
 373         MALLOC(cp, caddr_t, uap->len, M_KTRACE, M_WAITOK);
 374         if (!copyin(uap->addr, cp, uap->len)) {
 375                 kth->ktr_buf = cp;
 376                 kth->ktr_len = uap->len;
 377                 ktrwrite(vp, kth, NULL);
 378         }
 379         if (vp)
 380                 vrele(vp);
 381         FREE(kth, M_KTRACE);
 382         FREE(cp, M_KTRACE);
 383         p->p_traceflag &= ~KTRFAC_ACTIVE;
 384
 385         return (0);
 386 #else
 387         return (ENOSYS);
 388 #endif
 389 }
 390
 391 #ifdef KTRACE
 392 static int
 393 ktrops(struct proc *curp, struct proc *p, int ops, int facs, struct vnode *vp)
 394 {
 395
 396         if (!ktrcanset(curp, p))
 397                 return (0);
 398         if (ops == KTROP_SET) {
 399                 if (p->p_tracep != vp) {
 400                         struct vnode *vtmp;
 401
 402                         /*
 403                          * if trace file already in use, relinquish
 404                          */
 405                         vref(vp);
 406                         while ((vtmp = p->p_tracep) != NULL) {
 407                                 p->p_tracep = NULL;
 408                                 vrele(vtmp);
 409                         }
 410                         p->p_tracep = vp;
 411                 }
 412                 p->p_traceflag |= facs;
 413                 if (curp->p_ucred->cr_uid == 0)
 414                         p->p_traceflag |= KTRFAC_ROOT;
 415         } else {
 416                 /* KTROP_CLEAR */
 417                 if (((p->p_traceflag &= ~facs) & KTRFAC_MASK) == 0) {
 418                         struct vnode *vtmp;
 419
 420                         /* no more tracing */
 421                         p->p_traceflag = 0;
 422                         if ((vtmp = p->p_tracep) != NULL) {
 423                                 p->p_tracep = NULL;
 424                                 vrele(vtmp);
 425                         }
 426                 }
 427         }
 428
 429         return (1);
 430 }
 431
 432 static int
 433 ktrsetchildren(struct proc *curp, struct proc *top, int ops, int facs,
 434                struct vnode *vp)
 435 {
 436         struct proc *p;
 437         int ret = 0;
 438
 439         p = top;
 440         for (;;) {
 441                 ret |= ktrops(curp, p, ops, facs, vp);
 442                 /*
 443                  * If this process has children, descend to them next,
 444                  * otherwise do any siblings, and if done with this level,
 445                  * follow back up the tree (but not past top).
 446                  */
 447                 if (!LIST_EMPTY(&p->p_children))
 448                         p = LIST_FIRST(&p->p_children);
 449                 else for (;;) {
 450                         if (p == top)
 451                                 return (ret);
 452                         if (LIST_NEXT(p, p_sibling)) {
 453                                 p = LIST_NEXT(p, p_sibling);
 454                                 break;
 455                         }
 456                         p = p->p_pptr;
 457                 }
 458         }
 459         /*NOTREACHED*/
 460 }
 461
 462 static void
 463 ktrwrite(struct vnode *vp, struct ktr_header *kth, struct uio *uio)
 464 {
 465         struct uio auio;
 466         struct iovec aiov[2];
 467         struct thread *td = curthread;
 468         struct proc *p = td->td_proc;   /* XXX */
 469         int error;
 470
 471         if (vp == NULL)
 472                 return;
 473         auio.uio_iov = &aiov[0];
 474         auio.uio_offset = 0;
 475         auio.uio_segflg = UIO_SYSSPACE;
 476         auio.uio_rw = UIO_WRITE;
 477         aiov[0].iov_base = (caddr_t)kth;
 478         aiov[0].iov_len = sizeof(struct ktr_header);
 479         auio.uio_resid = sizeof(struct ktr_header);
 480         auio.uio_iovcnt = 1;
 481         auio.uio_td = curthread;
 482         if (kth->ktr_len > 0) {
 483                 auio.uio_iovcnt++;
 484                 aiov[1].iov_base = kth->ktr_buf;
 485                 aiov[1].iov_len = kth->ktr_len;
 486                 auio.uio_resid += kth->ktr_len;
 487                 if (uio != NULL)
 488                         kth->ktr_len += uio->uio_resid;
 489         }
 490         VOP_LEASE(vp, td, p->p_ucred, LEASE_WRITE);
 491         vn_lock(vp, NULL, LK_EXCLUSIVE | LK_RETRY, td);
 492         error = VOP_WRITE(vp, &auio, IO_UNIT | IO_APPEND, p->p_ucred);
 493         if (error == 0 && uio != NULL) {
 494                 VOP_LEASE(vp, td, p->p_ucred, LEASE_WRITE);
 495                 error = VOP_WRITE(vp, uio, IO_UNIT | IO_APPEND, p->p_ucred);
 496         }
 497         VOP_UNLOCK(vp, NULL, 0, td);
 498         if (!error)
 499                 return;
 500         /*
 501          * If error encountered, give up tracing on this vnode.  XXX what
 502          * happens to the loop if vrele() blocks?
 503          */
 504         log(LOG_NOTICE, "ktrace write failed, errno %d, tracing stopped\n",
 505             error);
 506         FOREACH_PROC_IN_SYSTEM(p) {
 507                 if (p->p_tracep == vp) {
 508                         p->p_tracep = NULL;
 509                         p->p_traceflag = 0;
 510                         vrele(vp);
 511                 }
 512         }
 513 }
 514
 515 /*
 516  * Return true if caller has permission to set the ktracing state
 517  * of target.  Essentially, the target can't possess any
 518  * more permissions than the caller.  KTRFAC_ROOT signifies that
 519  * root previously set the tracing status on the target process, and
 520  * so, only root may further change it.
 521  *
 522  * TODO: check groups.  use caller effective gid.
 523  */
 524 static int
 525 ktrcanset(struct proc *callp, struct proc *targetp)
 526 {
 527         struct ucred *caller = callp->p_ucred;
 528         struct ucred *target = targetp->p_ucred;
 529
 530         if (!PRISON_CHECK(caller, target))
 531                 return (0);
 532         if ((caller->cr_uid == target->cr_ruid &&
 533              target->cr_ruid == target->cr_svuid &&
 534              caller->cr_rgid == target->cr_rgid &&      /* XXX */
 535              target->cr_rgid == target->cr_svgid &&
 536              (targetp->p_traceflag & KTRFAC_ROOT) == 0 &&
 537              (targetp->p_flag & P_SUGID) == 0) ||
 538              caller->cr_uid == 0)
 539                 return (1);
 540
 541         return (0);
 542 }
 543
 544 #endif /* KTRACE */