Home | History | Annotate | Line # | Download | only in kern
kern_ktrace.c revision 1.105.4.11
      1 /*	$NetBSD: kern_ktrace.c,v 1.105.4.11 2007/02/06 19:14:40 ad Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1989, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. Neither the name of the University nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  *
     31  *	@(#)kern_ktrace.c	8.5 (Berkeley) 5/14/95
     32  */
     33 
     34 #include <sys/cdefs.h>
     35 __KERNEL_RCSID(0, "$NetBSD: kern_ktrace.c,v 1.105.4.11 2007/02/06 19:14:40 ad Exp $");
     36 
     37 #include "opt_ktrace.h"
     38 #include "opt_compat_mach.h"
     39 
     40 #include <sys/param.h>
     41 #include <sys/systm.h>
     42 #include <sys/proc.h>
     43 #include <sys/file.h>
     44 #include <sys/namei.h>
     45 #include <sys/vnode.h>
     46 #include <sys/kernel.h>
     47 #include <sys/kthread.h>
     48 #include <sys/ktrace.h>
     49 #include <sys/kmem.h>
     50 #include <sys/syslog.h>
     51 #include <sys/filedesc.h>
     52 #include <sys/ioctl.h>
     53 #include <sys/callout.h>
     54 #include <sys/kauth.h>
     55 
     56 #include <sys/mount.h>
     57 #include <sys/syscallargs.h>
     58 
     59 #ifdef KTRACE
     60 
     61 /*
     62  * XXX:
     63  *	- need better error reporting?
     64  *	- userland utility to sort ktrace.out by timestamp.
     65  *	- keep minimum information in ktrace_entry when rest of alloc failed.
     66  *	- enlarge ktrace_entry so that small entry won't require additional
     67  *	  alloc?
     68  *	- per trace control of configurable parameters.
     69  */
     70 
     71 struct ktrace_entry {
     72 	TAILQ_ENTRY(ktrace_entry) kte_list;
     73 	struct	ktr_header kte_kth;
     74 	void	*kte_buf;
     75 	size_t	kte_bufsz;
     76 #define	KTE_SPACE		32
     77 	uint8_t kte_space[KTE_SPACE];
     78 };
     79 
     80 struct ktr_desc {
     81 	TAILQ_ENTRY(ktr_desc) ktd_list;
     82 	int ktd_flags;
     83 #define	KTDF_WAIT		0x0001
     84 #define	KTDF_DONE		0x0002
     85 #define	KTDF_BLOCKING		0x0004
     86 #define	KTDF_INTERACTIVE	0x0008
     87 	int ktd_error;
     88 #define	KTDE_ENOMEM		0x0001
     89 #define	KTDE_ENOSPC		0x0002
     90 	int ktd_errcnt;
     91 	int ktd_ref;			/* # of reference */
     92 	int ktd_qcount;			/* # of entry in the queue */
     93 
     94 	/*
     95 	 * Params to control behaviour.
     96 	 */
     97 	int ktd_delayqcnt;		/* # of entry allowed to delay */
     98 	int ktd_wakedelay;		/* delay of wakeup in *tick* */
     99 	int ktd_intrwakdl;		/* ditto, but when interactive */
    100 
    101 	struct file *ktd_fp;		/* trace output file */
    102 	struct proc *ktd_proc;		/* our kernel thread */
    103 	TAILQ_HEAD(, ktrace_entry) ktd_queue;
    104 	struct callout ktd_wakch;	/* delayed wakeup */
    105 	kcondvar_t ktd_sync_cv;
    106 	kcondvar_t ktd_cv;
    107 };
    108 
    109 static int	ktealloc(struct ktrace_entry **, void **, struct lwp *, int,
    110 			 size_t);
    111 static void	ktrwrite(struct ktr_desc *, struct ktrace_entry *);
    112 static int	ktrace_common(struct lwp *, int, int, int, struct file *);
    113 static int	ktrops(struct lwp *, struct proc *, int, int,
    114 		    struct ktr_desc *);
    115 static int	ktrsetchildren(struct lwp *, struct proc *, int, int,
    116 		    struct ktr_desc *);
    117 static int	ktrcanset(struct lwp *, struct proc *);
    118 static int	ktrsamefile(struct file *, struct file *);
    119 
    120 static struct ktr_desc *
    121 		ktd_lookup(struct file *);
    122 static void	ktdrel(struct ktr_desc *);
    123 static void	ktdref(struct ktr_desc *);
    124 static void	ktraddentry(struct lwp *, struct ktrace_entry *, int);
    125 /* Flags for ktraddentry (3rd arg) */
    126 #define	KTA_NOWAIT		0x0000
    127 #define	KTA_WAITOK		0x0001
    128 #define	KTA_LARGE		0x0002
    129 static void	ktefree(struct ktrace_entry *);
    130 static void	ktd_logerrl(struct ktr_desc *, int);
    131 static void	ktrace_thread(void *);
    132 static int	ktrderefall(struct ktr_desc *, int);
    133 
    134 /*
    135  * Default vaules.
    136  */
    137 #define	KTD_MAXENTRY		1000	/* XXX: tune */
    138 #define	KTD_TIMEOUT		5	/* XXX: tune */
    139 #define	KTD_DELAYQCNT		100	/* XXX: tune */
    140 #define	KTD_WAKEDELAY		5000	/* XXX: tune */
    141 #define	KTD_INTRWAKDL		100	/* XXX: tune */
    142 
    143 /*
    144  * Patchable variables.
    145  */
    146 int ktd_maxentry = KTD_MAXENTRY;	/* max # of entry in the queue */
    147 int ktd_timeout = KTD_TIMEOUT;		/* timeout in seconds */
    148 int ktd_delayqcnt = KTD_DELAYQCNT;	/* # of entry allowed to delay */
    149 int ktd_wakedelay = KTD_WAKEDELAY;	/* delay of wakeup in *ms* */
    150 int ktd_intrwakdl = KTD_INTRWAKDL;	/* ditto, but when interactive */
    151 
    152 kmutex_t ktrace_mutex;
    153 static TAILQ_HEAD(, ktr_desc) ktdq = TAILQ_HEAD_INITIALIZER(ktdq);
    154 
    155 MALLOC_DEFINE(M_KTRACE, "ktrace", "ktrace data buffer");
    156 POOL_INIT(kte_pool, sizeof(struct ktrace_entry), 0, 0, 0,
    157     "ktepl", &pool_allocator_nointr);
    158 
    159 static inline void
    160 ktd_wakeup(struct ktr_desc *ktd)
    161 {
    162 
    163 	callout_stop(&ktd->ktd_wakch);
    164 	cv_broadcast(&ktd->ktd_cv);
    165 }
    166 
    167 static void
    168 ktd_logerrl(struct ktr_desc *ktd, int error)
    169 {
    170 
    171 	ktd->ktd_error |= error;
    172 	ktd->ktd_errcnt++;
    173 }
    174 
    175 #if 0
    176 static void
    177 ktd_logerr(struct proc *p, int error)
    178 {
    179 	struct ktr_desc *ktd;
    180 
    181 	LOCK_ASSERT(mutex_owned(&ktrace_mutex));
    182 
    183 	ktd = p->p_tracep;
    184 	if (ktd == NULL)
    185 		return;
    186 
    187 	ktd_logerrl(ktd, error);
    188 }
    189 #endif
    190 
    191 static inline int
    192 ktrenter(struct lwp *l)
    193 {
    194 
    195 	if ((l->l_pflag & LP_KTRACTIVE) != 0)
    196 		return 1;
    197 	l->l_pflag |= LP_KTRACTIVE;
    198 	return 0;
    199 }
    200 
    201 static inline void
    202 ktrexit(struct lwp *l)
    203 {
    204 
    205 	l->l_pflag &= ~LP_KTRACTIVE;
    206 }
    207 
    208 /*
    209  * Initialise the ktrace system.
    210  */
    211 void
    212 ktrinit(void)
    213 {
    214 
    215 	mutex_init(&ktrace_mutex, MUTEX_DEFAULT, IPL_NONE);
    216 }
    217 
    218 /*
    219  * Release a reference.  Called with ktrace_mutex held.
    220  */
    221 void
    222 ktdrel(struct ktr_desc *ktd)
    223 {
    224 
    225 	LOCK_ASSERT(mutex_owned(&ktrace_mutex));
    226 
    227 	KDASSERT(ktd->ktd_ref != 0);
    228 	KASSERT(ktd->ktd_ref > 0);
    229 	if (--ktd->ktd_ref <= 0) {
    230 		ktd->ktd_flags |= KTDF_DONE;
    231 		cv_broadcast(&ktd->ktd_cv);
    232 	}
    233 }
    234 
    235 void
    236 ktdref(struct ktr_desc *ktd)
    237 {
    238 
    239 	LOCK_ASSERT(mutex_owned(&ktrace_mutex));
    240 
    241 	ktd->ktd_ref++;
    242 }
    243 
    244 struct ktr_desc *
    245 ktd_lookup(struct file *fp)
    246 {
    247 	struct ktr_desc *ktd;
    248 
    249 	LOCK_ASSERT(mutex_owned(&ktrace_mutex));
    250 
    251 	for (ktd = TAILQ_FIRST(&ktdq); ktd != NULL;
    252 	    ktd = TAILQ_NEXT(ktd, ktd_list)) {
    253 		if (ktrsamefile(ktd->ktd_fp, fp)) {
    254 			ktd->ktd_ref++;
    255 			break;
    256 		}
    257 	}
    258 
    259 	return (ktd);
    260 }
    261 
    262 void
    263 ktraddentry(struct lwp *l, struct ktrace_entry *kte, int flags)
    264 {
    265 	struct proc *p = l->l_proc;
    266 	struct ktr_desc *ktd;
    267 #ifdef DEBUG
    268 	struct timeval t1, t2;
    269 #endif
    270 
    271 	mutex_enter(&ktrace_mutex);
    272 
    273 	if (p->p_traceflag & KTRFAC_TRC_EMUL) {
    274 		/* Add emulation trace before first entry for this process */
    275 		p->p_traceflag &= ~KTRFAC_TRC_EMUL;
    276 		mutex_exit(&ktrace_mutex);
    277 		ktrexit(l);
    278 		ktremul(l);
    279 		(void)ktrenter(l);
    280 		mutex_enter(&ktrace_mutex);
    281 	}
    282 
    283 	/*
    284 	 * Tracing may be canceled while we were sleeping waiting for
    285 	 * memory.
    286 	 */
    287 	ktd = p->p_tracep;
    288 	if (ktd == NULL)
    289 		goto freekte;
    290 
    291 	/*
    292 	 * Bump reference count so that the object will remain while
    293 	 * we are here.  Note that the trace is controlled by other
    294 	 * process.
    295 	 */
    296 	ktdref(ktd);
    297 
    298 	if (ktd->ktd_flags & KTDF_DONE)
    299 		goto relktd;
    300 
    301 	if (ktd->ktd_qcount > ktd_maxentry) {
    302 		ktd_logerrl(ktd, KTDE_ENOSPC);
    303 		goto relktd;
    304 	}
    305 	TAILQ_INSERT_TAIL(&ktd->ktd_queue, kte, kte_list);
    306 	ktd->ktd_qcount++;
    307 	if (ktd->ktd_flags & KTDF_BLOCKING)
    308 		goto skip_sync;
    309 
    310 	if (flags & KTA_WAITOK &&
    311 	    (/* flags & KTA_LARGE */0 || ktd->ktd_flags & KTDF_WAIT ||
    312 	    ktd->ktd_qcount > ktd_maxentry >> 1))
    313 		/*
    314 		 * Sync with writer thread since we're requesting rather
    315 		 * big one or many requests are pending.
    316 		 */
    317 		do {
    318 			ktd->ktd_flags |= KTDF_WAIT;
    319 			ktd_wakeup(ktd);
    320 #ifdef DEBUG
    321 			getmicrouptime(&t1);
    322 #endif
    323 			if (cv_timedwait(&ktd->ktd_sync_cv, &ktrace_mutex,
    324 			    ktd_timeout * hz) != 0) {
    325 				ktd->ktd_flags |= KTDF_BLOCKING;
    326 				/*
    327 				 * Maybe the writer thread is blocking
    328 				 * completely for some reason, but
    329 				 * don't stop target process forever.
    330 				 */
    331 				log(LOG_NOTICE, "ktrace timeout\n");
    332 				break;
    333 			}
    334 #ifdef DEBUG
    335 			getmicrouptime(&t2);
    336 			timersub(&t2, &t1, &t2);
    337 			if (t2.tv_sec > 0)
    338 				log(LOG_NOTICE,
    339 				    "ktrace long wait: %ld.%06ld\n",
    340 				    t2.tv_sec, t2.tv_usec);
    341 #endif
    342 		} while (p->p_tracep == ktd &&
    343 		    (ktd->ktd_flags & (KTDF_WAIT | KTDF_DONE)) == KTDF_WAIT);
    344 	else {
    345 		/* Schedule delayed wakeup */
    346 		if (ktd->ktd_qcount > ktd->ktd_delayqcnt)
    347 			ktd_wakeup(ktd);	/* Wakeup now */
    348 		else if (!callout_pending(&ktd->ktd_wakch))
    349 			callout_reset(&ktd->ktd_wakch,
    350 			    ktd->ktd_flags & KTDF_INTERACTIVE ?
    351 			    ktd->ktd_intrwakdl : ktd->ktd_wakedelay,
    352 			    (void (*)(void *))ktd_wakeup,
    353 			    &ktd->ktd_cv);
    354 	}
    355 
    356 skip_sync:
    357 	ktdrel(ktd);
    358 	mutex_exit(&ktrace_mutex);
    359 	ktrexit(l);
    360 	return;
    361 
    362 relktd:
    363 	ktdrel(ktd);
    364 
    365 freekte:
    366 	mutex_exit(&ktrace_mutex);
    367 	ktefree(kte);
    368 	ktrexit(l);
    369 }
    370 
    371 void
    372 ktefree(struct ktrace_entry *kte)
    373 {
    374 
    375 	KERNEL_LOCK(1, curlwp);			/* XXXSMP */
    376 	if (kte->kte_buf != kte->kte_space)
    377 		kmem_free(kte->kte_buf, kte->kte_bufsz);
    378 	pool_put(&kte_pool, kte);
    379 	KERNEL_UNLOCK_ONE(curlwp);		/* XXXSMP */
    380 }
    381 
    382 /*
    383  * "deep" compare of two files for the purposes of clearing a trace.
    384  * Returns true if they're the same open file, or if they point at the
    385  * same underlying vnode/socket.
    386  */
    387 
    388 int
    389 ktrsamefile(struct file *f1, struct file *f2)
    390 {
    391 
    392 	return ((f1 == f2) ||
    393 	    ((f1 != NULL) && (f2 != NULL) &&
    394 		(f1->f_type == f2->f_type) &&
    395 		(f1->f_data == f2->f_data)));
    396 }
    397 
    398 void
    399 ktrderef(struct proc *p)
    400 {
    401 	struct ktr_desc *ktd = p->p_tracep;
    402 
    403 	LOCK_ASSERT(mutex_owned(&ktrace_mutex));
    404 
    405 	p->p_traceflag = 0;
    406 	if (ktd == NULL)
    407 		return;
    408 	p->p_tracep = NULL;
    409 
    410 	cv_broadcast(&ktd->ktd_sync_cv);
    411 	ktdrel(ktd);
    412 }
    413 
    414 void
    415 ktradref(struct proc *p)
    416 {
    417 	struct ktr_desc *ktd = p->p_tracep;
    418 
    419 	LOCK_ASSERT(mutex_owned(&ktrace_mutex));
    420 
    421 	ktdref(ktd);
    422 }
    423 
    424 int
    425 ktrderefall(struct ktr_desc *ktd, int auth)
    426 {
    427 	struct lwp *curl = curlwp;
    428 	struct proc *p;
    429 	int error = 0;
    430 
    431 	rw_enter(&proclist_lock, RW_READER);
    432 	PROCLIST_FOREACH(p, &allproc) {
    433 		if (p->p_tracep != ktd)
    434 			continue;
    435 		mutex_enter(&p->p_mutex);
    436 		mutex_enter(&ktrace_mutex);
    437 		if (p->p_tracep == ktd) {
    438 			if (!auth || ktrcanset(curl, p))
    439 				ktrderef(p);
    440 			else
    441 				error = EPERM;
    442 		}
    443 		mutex_exit(&ktrace_mutex);
    444 		mutex_exit(&p->p_mutex);
    445 	}
    446 	rw_exit(&proclist_lock);
    447 
    448 	return error;
    449 }
    450 
    451 int
    452 ktealloc(struct ktrace_entry **ktep, void **bufp, struct lwp *l, int type,
    453 	 size_t sz)
    454 {
    455 	struct proc *p = l->l_proc;
    456 	struct ktrace_entry *kte;
    457 	struct ktr_header *kth;
    458 	void *buf;
    459 
    460 	if (ktrenter(l))
    461 		return EAGAIN;
    462 
    463 	KERNEL_LOCK(1, l);			/* XXXSMP */
    464 	kte = pool_get(&kte_pool, PR_WAITOK);
    465 	if (sz > sizeof(kte->kte_space)) {
    466 		if ((buf = kmem_alloc(sz, KM_SLEEP)) == NULL) {
    467 			pool_put(&kte_pool, kte);
    468 			KERNEL_UNLOCK_ONE(l);	/* XXXSMP */
    469 			ktrexit(l);
    470 			return ENOMEM;
    471 		}
    472 	} else
    473 		buf = kte->kte_space;
    474 	KERNEL_UNLOCK_ONE(l);			/* XXXSMP */
    475 
    476 	kte->kte_bufsz = sz;
    477 	kte->kte_buf = buf;
    478 
    479 	kth = &kte->kte_kth;
    480 	(void)memset(kth, 0, sizeof(*kth));
    481 	kth->ktr_len = sz;
    482 	kth->ktr_type = type;
    483 	kth->ktr_pid = p->p_pid;
    484 	memcpy(kth->ktr_comm, p->p_comm, MAXCOMLEN);
    485 	kth->ktr_version = KTRFAC_VERSION(p->p_traceflag);
    486 
    487 	switch (KTRFAC_VERSION(p->p_traceflag)) {
    488 	case 0:
    489 		/* This is the original format */
    490 		microtime(&kth->ktr_tv);
    491 		break;
    492 	case 1:
    493 		kth->ktr_lid = l->l_lid;
    494 		nanotime(&kth->ktr_time);
    495 		break;
    496 	default:
    497 		break;
    498 	}
    499 
    500 	*ktep = kte;
    501 	*bufp = buf;
    502 
    503 	return 0;
    504 }
    505 
    506 void
    507 ktrsyscall(struct lwp *l, register_t code, register_t realcode,
    508     const struct sysent *callp, register_t args[])
    509 {
    510 	struct proc *p = l->l_proc;
    511 	struct ktrace_entry *kte;
    512 	struct ktr_syscall *ktp;
    513 	register_t *argp;
    514 	int argsize;
    515 	size_t len;
    516 	u_int i;
    517 
    518 	if (callp == NULL)
    519 		callp = p->p_emul->e_sysent;
    520 
    521 	argsize = callp[code].sy_argsize;
    522 #ifdef _LP64
    523 	if (p->p_flag & P_32)
    524 		argsize = argsize << 1;
    525 #endif
    526 	len = sizeof(struct ktr_syscall) + argsize;
    527 
    528 	if (ktealloc(&kte, (void *)&ktp, l, KTR_SYSCALL, len))
    529 		return;
    530 
    531 	ktp->ktr_code = realcode;
    532 	ktp->ktr_argsize = argsize;
    533 	argp = (register_t *)(ktp + 1);
    534 	for (i = 0; i < (argsize / sizeof(*argp)); i++)
    535 		*argp++ = args[i];
    536 
    537 	ktraddentry(l, kte, KTA_WAITOK);
    538 }
    539 
    540 void
    541 ktrsysret(struct lwp *l, register_t code, int error, register_t *retval)
    542 {
    543 	struct ktrace_entry *kte;
    544 	struct ktr_sysret *ktp;
    545 
    546 	if (ktealloc(&kte, (void *)&ktp, l, KTR_SYSRET,
    547 	    sizeof(struct ktr_sysret)))
    548 		return;
    549 
    550 	ktp->ktr_code = code;
    551 	ktp->ktr_eosys = 0;			/* XXX unused */
    552 	ktp->ktr_error = error;
    553 	ktp->ktr_retval = retval ? retval[0] : 0;
    554 	ktp->ktr_retval_1 = retval ? retval[1] : 0;
    555 
    556 	ktraddentry(l, kte, KTA_WAITOK);
    557 }
    558 
    559 /*
    560  * XXX: ndp->ni_pathlen should be passed.
    561  */
    562 void
    563 ktrnamei(struct lwp *l, char *path)
    564 {
    565 
    566 	ktrkmem(l, KTR_NAMEI, path, strlen(path));
    567 }
    568 
    569 void
    570 ktremul(struct lwp *l)
    571 {
    572 	const char *emul = l->l_proc->p_emul->e_name;
    573 
    574 	ktrkmem(l, KTR_EMUL, emul, strlen(emul));
    575 }
    576 
    577 void
    578 ktrkmem(struct lwp *l, int type, const void *bf, size_t len)
    579 {
    580 	struct ktrace_entry *kte;
    581 	void *buf;
    582 
    583 	if (ktealloc(&kte, &buf, l, type, len))
    584 		return;
    585 	memcpy(buf, bf, len);
    586 	ktraddentry(l, kte, KTA_WAITOK);
    587 }
    588 
    589 void
    590 ktrgenio(struct lwp *l, int fd, enum uio_rw rw, struct iovec *iov,
    591 	 int len, int error)
    592 {
    593 	struct ktrace_entry *kte;
    594 	struct ktr_genio *ktp;
    595 	int resid = len, cnt;
    596 	caddr_t cp;
    597 	int buflen;
    598 
    599 	if (error)
    600 		return;
    601 
    602  next:
    603 	buflen = min(PAGE_SIZE, resid + sizeof(struct ktr_genio));
    604 
    605 	if (ktealloc(&kte, (void *)&ktp, l, KTR_GENIO, buflen))
    606 		return;
    607 
    608 	ktp->ktr_fd = fd;
    609 	ktp->ktr_rw = rw;
    610 
    611 	cp = (caddr_t)(ktp + 1);
    612 	buflen -= sizeof(struct ktr_genio);
    613 	kte->kte_kth.ktr_len = sizeof(struct ktr_genio);
    614 
    615 	while (buflen > 0) {
    616 		cnt = min(iov->iov_len, buflen);
    617 		if (copyin(iov->iov_base, cp, cnt) != 0)
    618 			goto out;
    619 		kte->kte_kth.ktr_len += cnt;
    620 		buflen -= cnt;
    621 		resid -= cnt;
    622 		iov->iov_len -= cnt;
    623 		if (iov->iov_len == 0)
    624 			iov++;
    625 		else
    626 			iov->iov_base = (caddr_t)iov->iov_base + cnt;
    627 	}
    628 
    629 	/*
    630 	 * Don't push so many entry at once.  It will cause kmem map
    631 	 * shortage.
    632 	 */
    633 	ktraddentry(l, kte, KTA_WAITOK | KTA_LARGE);
    634 	if (resid > 0) {
    635 		if (curcpu()->ci_schedstate.spc_flags & SPCF_SHOULDYIELD) {
    636 			(void)ktrenter(l);
    637 			preempt();
    638 			ktrexit(l);
    639 		}
    640 
    641 		goto next;
    642 	}
    643 
    644 	return;
    645 
    646 out:
    647 	ktefree(kte);
    648 	ktrexit(l);
    649 }
    650 
    651 void
    652 ktrpsig(struct lwp *l, int sig, sig_t action, const sigset_t *mask,
    653     const ksiginfo_t *ksi)
    654 {
    655 	struct ktrace_entry *kte;
    656 	struct {
    657 		struct ktr_psig	kp;
    658 		siginfo_t	si;
    659 	} *kbuf;
    660 
    661 	if (ktealloc(&kte, (void *)&kbuf, l, KTR_PSIG, sizeof(*kbuf)))
    662 		return;
    663 
    664 	kbuf->kp.signo = (char)sig;
    665 	kbuf->kp.action = action;
    666 	kbuf->kp.mask = *mask;
    667 
    668 	if (ksi) {
    669 		kbuf->kp.code = KSI_TRAPCODE(ksi);
    670 		(void)memset(&kbuf->si, 0, sizeof(kbuf->si));
    671 		kbuf->si._info = ksi->ksi_info;
    672 		kte->kte_kth.ktr_len = sizeof(*kbuf);
    673 	} else {
    674 		kbuf->kp.code = 0;
    675 		kte->kte_kth.ktr_len = sizeof(struct ktr_psig);
    676 	}
    677 
    678 	ktraddentry(l, kte, KTA_WAITOK);
    679 }
    680 
    681 void
    682 ktrcsw(struct lwp *l, int out, int user)
    683 {
    684 	struct proc *p = l->l_proc;
    685 	struct ktrace_entry *kte;
    686 	struct ktr_csw *kc;
    687 
    688 	/*
    689 	 * Don't record context switches resulting from blocking on
    690 	 * locks; it's too easy to get duff results.
    691 	 */
    692 	if (l->l_syncobj == &turnstile_syncobj)
    693 		return;
    694 
    695 	/*
    696 	 * We can't sleep if we're already going to sleep (if original
    697 	 * condition is met during sleep, we hang up).
    698 	 *
    699 	 * XXX This is not ideal: it would be better to maintain a pool
    700 	 * of ktes and actually push this to the kthread when context
    701 	 * switch happens, however given the points where we are called
    702 	 * from that is difficult to do.
    703 	 */
    704 	if (out) {
    705 		if (ktrenter(l))
    706 			return;
    707 
    708 		switch (KTRFAC_VERSION(p->p_traceflag)) {
    709 		case 0:
    710 			/* This is the original format */
    711 			microtime(&l->l_ktrcsw.tv);
    712 			l->l_pflag |= LP_KTRCSW;
    713 			break;
    714 		case 1:
    715 			nanotime(&l->l_ktrcsw.ts);
    716 			l->l_pflag |= LP_KTRCSW;
    717 			break;
    718 		default:
    719 			break;
    720 		}
    721 
    722 		if (user)
    723 			l->l_pflag |= LP_KTRCSWUSER;
    724 		else
    725 			l->l_pflag &= ~LP_KTRCSWUSER;
    726 
    727 		ktrexit(l);
    728 		return;
    729 	}
    730 
    731 	/*
    732 	 * On the way back in, we need to record twice: once for entry, and
    733 	 * once for exit.
    734 	 */
    735 	if ((l->l_pflag & LP_KTRCSW) != 0) {
    736 		l->l_pflag &= ~LP_KTRCSW;
    737 
    738 		if (ktealloc(&kte, (void *)&kc, l, KTR_CSW, sizeof(*kc)))
    739 			return;
    740 
    741 		kc->out = 1;
    742 		kc->user = ((l->l_pflag & LP_KTRCSWUSER) != 0);
    743 
    744 		switch (KTRFAC_VERSION(p->p_traceflag)) {
    745 		case 0:
    746 			/* This is the original format */
    747 			memcpy(&kte->kte_kth.ktr_tv, &l->l_ktrcsw.tv,
    748 			    sizeof(kte->kte_kth.ktr_tv));
    749 			break;
    750 		case 1:
    751 			memcpy(&kte->kte_kth.ktr_time, &l->l_ktrcsw.ts,
    752 			    sizeof(kte->kte_kth.ktr_time));
    753 			break;
    754 		default:
    755 			break;
    756 		}
    757 
    758 		ktraddentry(l, kte, KTA_WAITOK);
    759 	}
    760 
    761 	if (ktealloc(&kte, (void *)&kc, l, KTR_CSW, sizeof(*kc)))
    762 		return;
    763 
    764 	kc->out = 0;
    765 	kc->user = user;
    766 
    767 	ktraddentry(l, kte, KTA_WAITOK);
    768 }
    769 
    770 int
    771 ktruser(struct lwp *l, const char *id, void *addr, size_t len, int ustr)
    772 {
    773 	struct ktrace_entry *kte;
    774 	struct ktr_user *ktp;
    775 	caddr_t user_dta;
    776 	int error;
    777 
    778 	if (len > KTR_USER_MAXLEN)
    779 		return ENOSPC;
    780 
    781 	error = ktealloc(&kte, (void *)&ktp, l, KTR_USER, sizeof(*ktp) + len);
    782 	if (error != 0)
    783 		return error;
    784 
    785 	if (ustr) {
    786 		if (copyinstr(id, ktp->ktr_id, KTR_USER_MAXIDLEN, NULL) != 0)
    787 			ktp->ktr_id[0] = '\0';
    788 	} else
    789 		strncpy(ktp->ktr_id, id, KTR_USER_MAXIDLEN);
    790 	ktp->ktr_id[KTR_USER_MAXIDLEN-1] = '\0';
    791 
    792 	user_dta = (caddr_t)(ktp + 1);
    793 	if ((error = copyin(addr, (void *)user_dta, len)) != 0)
    794 		len = 0;
    795 
    796 	ktraddentry(l, kte, KTA_WAITOK);
    797 	return error;
    798 }
    799 
    800 void
    801 ktrmmsg(struct lwp *l, const void *msgh, size_t size)
    802 {
    803 	ktrkmem(l, KTR_MMSG, msgh, size);
    804 }
    805 
    806 void
    807 ktrmool(struct lwp *l, const void *kaddr, size_t size, const void *uaddr)
    808 {
    809 	struct ktrace_entry *kte;
    810 	struct ktr_mool *kp;
    811 	struct ktr_mool *bf;
    812 
    813 	if (ktealloc(&kte, (void *)&kp, l, KTR_MOOL, size + sizeof(*kp)))
    814 		return;
    815 
    816 	kp->uaddr = uaddr;
    817 	kp->size = size;
    818 	bf = kp + 1; /* Skip uaddr and size */
    819 	(void)memcpy(bf, kaddr, size);
    820 
    821 	ktraddentry(l, kte, KTA_WAITOK);
    822 }
    823 
    824 void
    825 ktrmib(struct lwp *l, const int *name, u_int namelen)
    826 {
    827 	struct ktrace_entry *kte;
    828 	int *namep;
    829 	size_t size;
    830 
    831 	size = namelen * sizeof(*name);
    832 
    833 	if (ktealloc(&kte, (void *)&namep, l, KTR_MIB, size))
    834 		return;
    835 
    836 	(void)memcpy(namep, name, namelen * sizeof(*name));
    837 
    838 	ktraddentry(l, kte, KTA_WAITOK);
    839 }
    840 
    841 /* Interface and common routines */
    842 
    843 int
    844 ktrace_common(struct lwp *curl, int ops, int facs, int pid, struct file *fp)
    845 {
    846 	struct proc *curp;
    847 	struct proc *p;
    848 	struct pgrp *pg;
    849 	struct ktr_desc *ktd = NULL;
    850 	int ret = 0;
    851 	int error = 0;
    852 	int descend;
    853 
    854 	curp = curl->l_proc;
    855 	descend = ops & KTRFLAG_DESCEND;
    856 	facs = facs & ~((unsigned) KTRFAC_ROOT);
    857 
    858 	(void)ktrenter(curl);
    859 
    860 	switch (KTROP(ops)) {
    861 
    862 	case KTROP_CLEARFILE:
    863 		/*
    864 		 * Clear all uses of the tracefile
    865 		 */
    866 		mutex_enter(&ktrace_mutex);
    867 		ktd = ktd_lookup(fp);
    868 		mutex_exit(&ktrace_mutex);
    869 		if (ktd == NULL)
    870 			goto done;
    871 		error = ktrderefall(ktd, 1);
    872 		goto done;
    873 
    874 	case KTROP_SET:
    875 		mutex_enter(&ktrace_mutex);
    876 		ktd = ktd_lookup(fp);
    877 		mutex_exit(&ktrace_mutex);
    878 		if (ktd == NULL) {
    879 			ktd = kmem_alloc(sizeof(*ktd), KM_SLEEP);
    880 			TAILQ_INIT(&ktd->ktd_queue);
    881 			callout_init(&ktd->ktd_wakch);
    882 			cv_init(&ktd->ktd_cv, "ktrwait");
    883 			cv_init(&ktd->ktd_sync_cv, "ktrsync");
    884 			ktd->ktd_flags = ktd->ktd_qcount =
    885 			    ktd->ktd_error = ktd->ktd_errcnt = 0;
    886 			ktd->ktd_ref = 1;
    887 			ktd->ktd_delayqcnt = ktd_delayqcnt;
    888 			ktd->ktd_wakedelay = mstohz(ktd_wakedelay);
    889 			ktd->ktd_intrwakdl = mstohz(ktd_intrwakdl);
    890 			/*
    891 			 * XXX: not correct.  needs an way to detect
    892 			 * whether ktruss or ktrace.
    893 			 */
    894 			if (fp->f_type == DTYPE_PIPE)
    895 				ktd->ktd_flags |= KTDF_INTERACTIVE;
    896 
    897 			error = kthread_create1(ktrace_thread, ktd,
    898 			    &ktd->ktd_proc, "ktr %p", ktd);
    899 			if (error != 0) {
    900 				kmem_free(ktd, sizeof(*ktd));
    901 				goto done;
    902 			}
    903 
    904 			simple_lock(&fp->f_slock);
    905 			fp->f_count++;
    906 			simple_unlock(&fp->f_slock);
    907 			ktd->ktd_fp = fp;
    908 
    909 			mutex_enter(&ktrace_mutex);
    910 			if (ktd_lookup(fp) != NULL) {
    911 				ktdrel(ktd);
    912 				ktd = NULL;
    913 			} else
    914 				TAILQ_INSERT_TAIL(&ktdq, ktd, ktd_list);
    915 			mutex_exit(&ktrace_mutex);
    916 			if (ktd == NULL) {
    917 				tsleep(&lbolt, PWAIT, "ktrzzz", 0);
    918 				goto done;
    919 			}
    920 		}
    921 		break;
    922 
    923 	case KTROP_CLEAR:
    924 		break;
    925 	}
    926 
    927 	/*
    928 	 * need something to (un)trace (XXX - why is this here?)
    929 	 */
    930 	if (!facs) {
    931 		error = EINVAL;
    932 		goto done;
    933 	}
    934 
    935 	/*
    936 	 * do it
    937 	 */
    938 	rw_enter(&proclist_lock, RW_READER);
    939 	if (pid < 0) {
    940 		/*
    941 		 * by process group
    942 		 */
    943 		pg = pg_find(-pid, PFIND_LOCKED);
    944 		if (pg == NULL)
    945 			error = ESRCH;
    946 		else {
    947 			LIST_FOREACH(p, &pg->pg_members, p_pglist) {
    948 				if (descend)
    949 					ret |= ktrsetchildren(curl, p, ops,
    950 					    facs, ktd);
    951 				else
    952 					ret |= ktrops(curl, p, ops, facs,
    953 					    ktd);
    954 			}
    955 		}
    956 
    957 	} else {
    958 		/*
    959 		 * by pid
    960 		 */
    961 		p = p_find(pid, PFIND_LOCKED);
    962 		if (p == NULL)
    963 			error = ESRCH;
    964 		else if (descend)
    965 			ret |= ktrsetchildren(curl, p, ops, facs, ktd);
    966 		else
    967 			ret |= ktrops(curl, p, ops, facs, ktd);
    968 	}
    969 	rw_exit(&proclist_lock);	/* taken by p{g}_find */
    970 	if (error == 0 && !ret)
    971 		error = EPERM;
    972 done:
    973 	if (ktd != NULL) {
    974 		if (error != 0) {
    975 			/*
    976 			 * Wakeup the thread so that it can be die if we
    977 			 * can't trace any process.
    978 			 */
    979 			ktd_wakeup(ktd);
    980 		}
    981 		if (KTROP(ops) == KTROP_SET || KTROP(ops) == KTROP_CLEARFILE) {
    982 			mutex_enter(&ktrace_mutex);
    983 			ktdrel(ktd);
    984 			mutex_exit(&ktrace_mutex);
    985 		}
    986 	}
    987 	ktrexit(curl);
    988 	return (error);
    989 }
    990 
    991 /*
    992  * fktrace system call
    993  */
    994 /* ARGSUSED */
    995 int
    996 sys_fktrace(struct lwp *l, void *v, register_t *retval)
    997 {
    998 	struct sys_fktrace_args /* {
    999 		syscallarg(int) fd;
   1000 		syscallarg(int) ops;
   1001 		syscallarg(int) facs;
   1002 		syscallarg(int) pid;
   1003 	} */ *uap = v;
   1004 	struct file *fp = NULL;
   1005 	struct filedesc *fdp = l->l_proc->p_fd;
   1006 	int error;
   1007 
   1008 	fdp = l->l_proc->p_fd;
   1009 	if ((fp = fd_getfile(fdp, SCARG(uap, fd))) == NULL)
   1010 		return (EBADF);
   1011 
   1012 	FILE_USE(fp);
   1013 
   1014 	if ((fp->f_flag & FWRITE) == 0)
   1015 		error = EBADF;
   1016 	else
   1017 		error = ktrace_common(l, SCARG(uap, ops),
   1018 		    SCARG(uap, facs), SCARG(uap, pid), fp);
   1019 
   1020 	FILE_UNUSE(fp, l);
   1021 
   1022 	return error;
   1023 }
   1024 
   1025 /*
   1026  * ktrace system call
   1027  */
   1028 /* ARGSUSED */
   1029 int
   1030 sys_ktrace(struct lwp *l, void *v, register_t *retval)
   1031 {
   1032 	struct sys_ktrace_args /* {
   1033 		syscallarg(const char *) fname;
   1034 		syscallarg(int) ops;
   1035 		syscallarg(int) facs;
   1036 		syscallarg(int) pid;
   1037 	} */ *uap = v;
   1038 	struct vnode *vp = NULL;
   1039 	struct file *fp = NULL;
   1040 	struct nameidata nd;
   1041 	int error = 0;
   1042 	int fd;
   1043 
   1044 	if (ktrenter(l))
   1045 		return EAGAIN;
   1046 
   1047 	if (KTROP(SCARG(uap, ops)) != KTROP_CLEAR) {
   1048 		/*
   1049 		 * an operation which requires a file argument.
   1050 		 */
   1051 		NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, fname),
   1052 		    l);
   1053 		if ((error = vn_open(&nd, FREAD|FWRITE, 0)) != 0) {
   1054 			ktrexit(l);
   1055 			return (error);
   1056 		}
   1057 		vp = nd.ni_vp;
   1058 		VOP_UNLOCK(vp, 0);
   1059 		if (vp->v_type != VREG) {
   1060 			(void) vn_close(vp, FREAD|FWRITE, l->l_cred, l);
   1061 			ktrexit(l);
   1062 			return (EACCES);
   1063 		}
   1064 		/*
   1065 		 * XXX This uses up a file descriptor slot in the
   1066 		 * tracing process for the duration of this syscall.
   1067 		 * This is not expected to be a problem.  If
   1068 		 * falloc(NULL, ...) DTRT we could skip that part, but
   1069 		 * that would require changing its interface to allow
   1070 		 * the caller to pass in a ucred..
   1071 		 *
   1072 		 * This will FILE_USE the fp it returns, if any.
   1073 		 * Keep it in use until we return.
   1074 		 */
   1075 		if ((error = falloc(l, &fp, &fd)) != 0)
   1076 			goto done;
   1077 
   1078 		fp->f_flag = FWRITE;
   1079 		fp->f_type = DTYPE_VNODE;
   1080 		fp->f_ops = &vnops;
   1081 		fp->f_data = (caddr_t)vp;
   1082 		FILE_SET_MATURE(fp);
   1083 		vp = NULL;
   1084 	}
   1085 	error = ktrace_common(l, SCARG(uap, ops), SCARG(uap, facs),
   1086 	    SCARG(uap, pid), fp);
   1087 done:
   1088 	if (vp != NULL)
   1089 		(void) vn_close(vp, FWRITE, l->l_cred, l);
   1090 	if (fp != NULL) {
   1091 		FILE_UNUSE(fp, l);	/* release file */
   1092 		fdrelease(l, fd); 	/* release fd table slot */
   1093 	}
   1094 	return (error);
   1095 }
   1096 
   1097 int
   1098 ktrops(struct lwp *curl, struct proc *p, int ops, int facs,
   1099     struct ktr_desc *ktd)
   1100 {
   1101 	int vers = ops & KTRFAC_VER_MASK;
   1102 	int error = 0;
   1103 
   1104 	mutex_enter(&p->p_mutex);
   1105 	mutex_enter(&ktrace_mutex);
   1106 
   1107 	if (!ktrcanset(curl, p))
   1108 		goto out;
   1109 
   1110 	switch (vers) {
   1111 	case KTRFACv0:
   1112 	case KTRFACv1:
   1113 		break;
   1114 	default:
   1115 		error = EINVAL;
   1116 		goto out;
   1117 	}
   1118 
   1119 	if (KTROP(ops) == KTROP_SET) {
   1120 		if (p->p_tracep != ktd) {
   1121 			/*
   1122 			 * if trace file already in use, relinquish
   1123 			 */
   1124 			ktrderef(p);
   1125 			p->p_tracep = ktd;
   1126 			ktradref(p);
   1127 		}
   1128 		p->p_traceflag |= facs;
   1129 		if (kauth_authorize_generic(curl->l_cred,
   1130 		    KAUTH_GENERIC_ISSUSER, NULL) == 0)
   1131 			p->p_traceflag |= KTRFAC_ROOT;
   1132 	} else {
   1133 		/* KTROP_CLEAR */
   1134 		if (((p->p_traceflag &= ~facs) & KTRFAC_MASK) == 0) {
   1135 			/* no more tracing */
   1136 			ktrderef(p);
   1137 		}
   1138 	}
   1139 
   1140 	if (p->p_traceflag)
   1141 		p->p_traceflag |= vers;
   1142 	/*
   1143 	 * Emit an emulation record, every time there is a ktrace
   1144 	 * change/attach request.
   1145 	 */
   1146 	if (KTRPOINT(p, KTR_EMUL))
   1147 		p->p_traceflag |= KTRFAC_TRC_EMUL;
   1148 #ifdef __HAVE_SYSCALL_INTERN
   1149 	(*p->p_emul->e_syscall_intern)(p);
   1150 #endif
   1151 
   1152  out:
   1153  	mutex_exit(&ktrace_mutex);
   1154  	mutex_exit(&p->p_mutex);
   1155 
   1156 	return (1);
   1157 }
   1158 
   1159 int
   1160 ktrsetchildren(struct lwp *curl, struct proc *top, int ops, int facs,
   1161     struct ktr_desc *ktd)
   1162 {
   1163 	struct proc *p;
   1164 	int ret = 0;
   1165 
   1166 	LOCK_ASSERT(rw_lock_held(&proclist_lock));
   1167 
   1168 	p = top;
   1169 	for (;;) {
   1170 		ret |= ktrops(curl, p, ops, facs, ktd);
   1171 		/*
   1172 		 * If this process has children, descend to them next,
   1173 		 * otherwise do any siblings, and if done with this level,
   1174 		 * follow back up the tree (but not past top).
   1175 		 */
   1176 		if (LIST_FIRST(&p->p_children) != NULL) {
   1177 			p = LIST_FIRST(&p->p_children);
   1178 			continue;
   1179 		}
   1180 		for (;;) {
   1181 			if (p == top)
   1182 				return (ret);
   1183 			if (LIST_NEXT(p, p_sibling) != NULL) {
   1184 				p = LIST_NEXT(p, p_sibling);
   1185 				break;
   1186 			}
   1187 			p = p->p_pptr;
   1188 		}
   1189 	}
   1190 	/*NOTREACHED*/
   1191 }
   1192 
   1193 void
   1194 ktrwrite(struct ktr_desc *ktd, struct ktrace_entry *kte)
   1195 {
   1196 	struct uio auio;
   1197 	struct iovec aiov[64], *iov;
   1198 	struct ktrace_entry *top = kte;
   1199 	struct ktr_header *kth;
   1200 	struct file *fp = ktd->ktd_fp;
   1201 	int error;
   1202 next:
   1203 	auio.uio_iov = iov = &aiov[0];
   1204 	auio.uio_offset = 0;
   1205 	auio.uio_rw = UIO_WRITE;
   1206 	auio.uio_resid = 0;
   1207 	auio.uio_iovcnt = 0;
   1208 	UIO_SETUP_SYSSPACE(&auio);
   1209 	do {
   1210 		kth = &kte->kte_kth;
   1211 
   1212 		if (kth->ktr_version == 0) {
   1213 			/*
   1214 			 * Convert back to the old format fields
   1215 			 */
   1216 			TIMESPEC_TO_TIMEVAL(&kth->ktr_tv, &kth->ktr_time);
   1217 			kth->ktr_unused = NULL;
   1218 		}
   1219 		iov->iov_base = (caddr_t)kth;
   1220 		iov++->iov_len = sizeof(struct ktr_header);
   1221 		auio.uio_resid += sizeof(struct ktr_header);
   1222 		auio.uio_iovcnt++;
   1223 		if (kth->ktr_len > 0) {
   1224 			iov->iov_base = kte->kte_buf;
   1225 			iov++->iov_len = kth->ktr_len;
   1226 			auio.uio_resid += kth->ktr_len;
   1227 			auio.uio_iovcnt++;
   1228 		}
   1229 	} while ((kte = TAILQ_NEXT(kte, kte_list)) != NULL &&
   1230 	    auio.uio_iovcnt < sizeof(aiov) / sizeof(aiov[0]) - 1);
   1231 
   1232 again:
   1233 	simple_lock(&fp->f_slock);
   1234 	FILE_USE(fp);
   1235 	error = (*fp->f_ops->fo_write)(fp, &fp->f_offset, &auio,
   1236 	    fp->f_cred, FOF_UPDATE_OFFSET);
   1237 	FILE_UNUSE(fp, NULL);
   1238 	switch (error) {
   1239 
   1240 	case 0:
   1241 		if (auio.uio_resid > 0)
   1242 			goto again;
   1243 		if (kte != NULL)
   1244 			goto next;
   1245 		break;
   1246 
   1247 	case EWOULDBLOCK:
   1248 		kpause("ktrzzz", FALSE, 1, NULL);
   1249 		goto again;
   1250 
   1251 	default:
   1252 		/*
   1253 		 * If error encountered, give up tracing on this
   1254 		 * vnode.  Don't report EPIPE as this can easily
   1255 		 * happen with fktrace()/ktruss.
   1256 		 */
   1257 #ifndef DEBUG
   1258 		if (error != EPIPE)
   1259 #endif
   1260 			log(LOG_NOTICE,
   1261 			    "ktrace write failed, errno %d, tracing stopped\n",
   1262 			    error);
   1263 		(void)ktrderefall(ktd, 0);
   1264 	}
   1265 
   1266 	while ((kte = top) != NULL) {
   1267 		top = TAILQ_NEXT(top, kte_list);
   1268 		ktefree(kte);
   1269 	}
   1270 }
   1271 
   1272 void
   1273 ktrace_thread(void *arg)
   1274 {
   1275 	struct ktr_desc *ktd = arg;
   1276 	struct file *fp = ktd->ktd_fp;
   1277 	struct ktrace_entry *kte;
   1278 	int ktrerr, errcnt;
   1279 
   1280 	mutex_enter(&ktrace_mutex);
   1281 	for (;;) {
   1282 		kte = TAILQ_FIRST(&ktd->ktd_queue);
   1283 		if (kte == NULL) {
   1284 			if (ktd->ktd_flags & KTDF_WAIT) {
   1285 				ktd->ktd_flags &= ~(KTDF_WAIT | KTDF_BLOCKING);
   1286 				cv_broadcast(&ktd->ktd_sync_cv);
   1287 			}
   1288 			if (ktd->ktd_ref == 0)
   1289 				break;
   1290 			cv_wait(&ktd->ktd_cv, &ktrace_mutex);
   1291 			continue;
   1292 		}
   1293 		TAILQ_INIT(&ktd->ktd_queue);
   1294 		ktd->ktd_qcount = 0;
   1295 		ktrerr = ktd->ktd_error;
   1296 		errcnt = ktd->ktd_errcnt;
   1297 		ktd->ktd_error = ktd->ktd_errcnt = 0;
   1298 		mutex_exit(&ktrace_mutex);
   1299 
   1300 		if (ktrerr) {
   1301 			log(LOG_NOTICE,
   1302 			    "ktrace failed, fp %p, error 0x%x, total %d\n",
   1303 			    fp, ktrerr, errcnt);
   1304 		}
   1305 		ktrwrite(ktd, kte);
   1306 		mutex_enter(&ktrace_mutex);
   1307 	}
   1308 
   1309 	TAILQ_REMOVE(&ktdq, ktd, ktd_list);
   1310 	mutex_exit(&ktrace_mutex);
   1311 
   1312 	simple_lock(&fp->f_slock);
   1313 	FILE_USE(fp);
   1314 
   1315 	/*
   1316 	 * ktrace file descriptor can't be watched (are not visible to
   1317 	 * userspace), so no kqueue stuff here
   1318 	 * XXX: The above comment is wrong, because the fktrace file
   1319 	 * descriptor is available in userland.
   1320 	 */
   1321 	closef(fp, NULL);
   1322 
   1323 	callout_stop(&ktd->ktd_wakch);
   1324 	kmem_free(ktd, sizeof(*ktd));
   1325 
   1326 	kthread_exit(0);
   1327 }
   1328 
   1329 /*
   1330  * Return true if caller has permission to set the ktracing state
   1331  * of target.  Essentially, the target can't possess any
   1332  * more permissions than the caller.  KTRFAC_ROOT signifies that
   1333  * root previously set the tracing status on the target process, and
   1334  * so, only root may further change it.
   1335  *
   1336  * TODO: check groups.  use caller effective gid.
   1337  */
   1338 int
   1339 ktrcanset(struct lwp *calll, struct proc *targetp)
   1340 {
   1341 	LOCK_ASSERT(mutex_owned(&targetp->p_mutex));
   1342 	LOCK_ASSERT(mutex_owned(&ktrace_mutex));
   1343 
   1344 	if (kauth_authorize_process(calll->l_cred, KAUTH_PROCESS_CANKTRACE,
   1345 	    targetp, NULL, NULL, NULL) == 0)
   1346 		return (1);
   1347 
   1348 	return (0);
   1349 }
   1350 #endif /* KTRACE */
   1351 
   1352 /*
   1353  * Put user defined entry to ktrace records.
   1354  */
   1355 int
   1356 sys_utrace(struct lwp *l, void *v, register_t *retval)
   1357 {
   1358 #ifdef KTRACE
   1359 	struct sys_utrace_args /* {
   1360 		syscallarg(const char *) label;
   1361 		syscallarg(void *) addr;
   1362 		syscallarg(size_t) len;
   1363 	} */ *uap = v;
   1364 	struct proc *p = l->l_proc;
   1365 
   1366 	if (!KTRPOINT(p, KTR_USER))
   1367 		return (0);
   1368 
   1369 	return ktruser(l, SCARG(uap, label), SCARG(uap, addr),
   1370 	    SCARG(uap, len), 1);
   1371 #else /* !KTRACE */
   1372 	return ENOSYS;
   1373 #endif /* KTRACE */
   1374 }
   1375