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