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