Annotation of src/sys/kern/kern_ktrace.c, Revision 1.140.2.2
1.140.2.2! christos 1: /* $NetBSD: kern_ktrace.c,v 1.147 2008/10/15 06:51:20 wrstuden 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.140.2.2! christos 64: __KERNEL_RCSID(0, "$NetBSD: kern_ktrace.c,v 1.147 2008/10/15 06:51:20 wrstuden 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>
1.140.2.2! christos 83: #include <sys/sa.h>
1.13 cgd 84: #include <sys/syscallargs.h>
1.22 christos 85:
1.93 enami 86: /*
1.121 ad 87: * TODO:
1.93 enami 88: * - need better error reporting?
89: * - userland utility to sort ktrace.out by timestamp.
90: * - keep minimum information in ktrace_entry when rest of alloc failed.
91: * - per trace control of configurable parameters.
92: */
93:
94: struct ktrace_entry {
95: TAILQ_ENTRY(ktrace_entry) kte_list;
1.114 ad 96: struct ktr_header kte_kth;
97: void *kte_buf;
98: size_t kte_bufsz;
99: #define KTE_SPACE 32
100: uint8_t kte_space[KTE_SPACE];
1.93 enami 101: };
102:
103: struct ktr_desc {
104: TAILQ_ENTRY(ktr_desc) ktd_list;
105: int ktd_flags;
106: #define KTDF_WAIT 0x0001
107: #define KTDF_DONE 0x0002
108: #define KTDF_BLOCKING 0x0004
109: #define KTDF_INTERACTIVE 0x0008
110: int ktd_error;
111: #define KTDE_ENOMEM 0x0001
112: #define KTDE_ENOSPC 0x0002
113: int ktd_errcnt;
114: int ktd_ref; /* # of reference */
115: int ktd_qcount; /* # of entry in the queue */
116:
117: /*
118: * Params to control behaviour.
119: */
120: int ktd_delayqcnt; /* # of entry allowed to delay */
121: int ktd_wakedelay; /* delay of wakeup in *tick* */
122: int ktd_intrwakdl; /* ditto, but when interactive */
123:
1.140 ad 124: file_t *ktd_fp; /* trace output file */
1.125 ad 125: lwp_t *ktd_lwp; /* our kernel thread */
1.93 enami 126: TAILQ_HEAD(, ktrace_entry) ktd_queue;
1.124 ad 127: callout_t ktd_wakch; /* delayed wakeup */
1.114 ad 128: kcondvar_t ktd_sync_cv;
129: kcondvar_t ktd_cv;
1.93 enami 130: };
131:
1.125 ad 132: static int ktealloc(struct ktrace_entry **, void **, lwp_t *, int,
1.114 ad 133: size_t);
1.93 enami 134: static void ktrwrite(struct ktr_desc *, struct ktrace_entry *);
1.140 ad 135: static int ktrace_common(lwp_t *, int, int, int, file_t *);
1.125 ad 136: static int ktrops(lwp_t *, struct proc *, int, int,
1.93 enami 137: struct ktr_desc *);
1.125 ad 138: static int ktrsetchildren(lwp_t *, struct proc *, int, int,
1.93 enami 139: struct ktr_desc *);
1.125 ad 140: static int ktrcanset(lwp_t *, struct proc *);
1.140 ad 141: static int ktrsamefile(file_t *, file_t *);
1.125 ad 142: static void ktr_kmem(lwp_t *, int, const void *, size_t);
143: static void ktr_io(lwp_t *, int, enum uio_rw, struct iovec *, size_t);
1.93 enami 144:
145: static struct ktr_desc *
1.140 ad 146: ktd_lookup(file_t *);
1.93 enami 147: static void ktdrel(struct ktr_desc *);
148: static void ktdref(struct ktr_desc *);
1.125 ad 149: static void ktraddentry(lwp_t *, struct ktrace_entry *, int);
1.93 enami 150: /* Flags for ktraddentry (3rd arg) */
151: #define KTA_NOWAIT 0x0000
152: #define KTA_WAITOK 0x0001
153: #define KTA_LARGE 0x0002
154: static void ktefree(struct ktrace_entry *);
155: static void ktd_logerrl(struct ktr_desc *, int);
156: static void ktrace_thread(void *);
1.114 ad 157: static int ktrderefall(struct ktr_desc *, int);
1.93 enami 158:
159: /*
160: * Default vaules.
161: */
162: #define KTD_MAXENTRY 1000 /* XXX: tune */
163: #define KTD_TIMEOUT 5 /* XXX: tune */
164: #define KTD_DELAYQCNT 100 /* XXX: tune */
165: #define KTD_WAKEDELAY 5000 /* XXX: tune */
166: #define KTD_INTRWAKDL 100 /* XXX: tune */
167:
168: /*
169: * Patchable variables.
170: */
171: int ktd_maxentry = KTD_MAXENTRY; /* max # of entry in the queue */
172: int ktd_timeout = KTD_TIMEOUT; /* timeout in seconds */
173: int ktd_delayqcnt = KTD_DELAYQCNT; /* # of entry allowed to delay */
174: int ktd_wakedelay = KTD_WAKEDELAY; /* delay of wakeup in *ms* */
175: int ktd_intrwakdl = KTD_INTRWAKDL; /* ditto, but when interactive */
176:
1.125 ad 177: kmutex_t ktrace_lock;
178: int ktrace_on;
1.93 enami 179: static TAILQ_HEAD(, ktr_desc) ktdq = TAILQ_HEAD_INITIALIZER(ktdq);
1.140.2.2! christos 180: static pool_cache_t kte_cache;
1.93 enami 181:
1.121 ad 182: static void
1.93 enami 183: ktd_wakeup(struct ktr_desc *ktd)
184: {
185:
186: callout_stop(&ktd->ktd_wakch);
1.121 ad 187: cv_signal(&ktd->ktd_cv);
188: }
189:
190: static void
191: ktd_callout(void *arg)
192: {
193:
1.129 ad 194: mutex_enter(&ktrace_lock);
1.121 ad 195: ktd_wakeup(arg);
1.129 ad 196: mutex_exit(&ktrace_lock);
1.93 enami 197: }
198:
199: static void
200: ktd_logerrl(struct ktr_desc *ktd, int error)
201: {
202:
203: ktd->ktd_error |= error;
204: ktd->ktd_errcnt++;
205: }
206:
1.114 ad 207: #if 0
1.93 enami 208: static void
209: ktd_logerr(struct proc *p, int error)
210: {
1.114 ad 211: struct ktr_desc *ktd;
212:
1.125 ad 213: KASSERT(mutex_owned(&ktrace_lock));
1.93 enami 214:
1.114 ad 215: ktd = p->p_tracep;
1.93 enami 216: if (ktd == NULL)
217: return;
218:
219: ktd_logerrl(ktd, error);
1.114 ad 220: }
221: #endif
222:
223: static inline int
1.125 ad 224: ktrenter(lwp_t *l)
1.114 ad 225: {
226:
227: if ((l->l_pflag & LP_KTRACTIVE) != 0)
228: return 1;
229: l->l_pflag |= LP_KTRACTIVE;
230: return 0;
231: }
232:
233: static inline void
1.125 ad 234: ktrexit(lwp_t *l)
1.114 ad 235: {
236:
237: l->l_pflag &= ~LP_KTRACTIVE;
238: }
239:
240: /*
241: * Initialise the ktrace system.
242: */
243: void
244: ktrinit(void)
245: {
246:
1.125 ad 247: mutex_init(&ktrace_lock, MUTEX_DEFAULT, IPL_NONE);
1.140.2.2! christos 248: kte_cache = pool_cache_init(sizeof(struct ktrace_entry), 0, 0, 0,
! 249: "ktrace", &pool_allocator_nointr, IPL_NONE, NULL, NULL, NULL);
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,
1.140.2.1 christos 373: "ktrace long wait: %lld.%06ld\n",
374: (long long)t2.tv_sec, (long)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.140.2.2! christos 410: pool_cache_put(kte_cache, kte);
1.93 enami 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.140.2.2! christos 462: mutex_enter(proc_lock);
1.114 ad 463: PROCLIST_FOREACH(p, &allproc) {
1.140.2.2! christos 464: if ((p->p_flag & PK_MARKER) != 0 || p->p_tracep != ktd)
1.114 ad 465: continue;
1.140.2.2! christos 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.140.2.2! christos 475: mutex_exit(p->p_lock);
1.114 ad 476: }
1.140.2.2! christos 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;
1.140.2.1 christos 489: struct timespec ts;
1.114 ad 490: void *buf;
491:
492: if (ktrenter(l))
493: return EAGAIN;
1.1 cgd 494:
1.140.2.2! christos 495: kte = pool_cache_get(kte_cache, PR_WAITOK);
1.114 ad 496: if (sz > sizeof(kte->kte_space)) {
497: if ((buf = kmem_alloc(sz, KM_SLEEP)) == NULL) {
1.140.2.2! christos 498: pool_cache_put(kte_cache, kte);
1.114 ad 499: ktrexit(l);
500: return ENOMEM;
501: }
502: } else
503: buf = kte->kte_space;
504:
505: kte->kte_bufsz = sz;
506: kte->kte_buf = buf;
507:
508: kth = &kte->kte_kth;
1.90 christos 509: (void)memset(kth, 0, sizeof(*kth));
1.114 ad 510: kth->ktr_len = sz;
1.1 cgd 511: kth->ktr_type = type;
512: kth->ktr_pid = p->p_pid;
1.32 perry 513: memcpy(kth->ktr_comm, p->p_comm, MAXCOMLEN);
1.98 christos 514: kth->ktr_version = KTRFAC_VERSION(p->p_traceflag);
515:
1.140.2.1 christos 516: nanotime(&ts);
517: switch (KTRFAC_VERSION(p->p_traceflag)) {
518: case 0:
519: /* This is the original format */
520: kth->ktr_otv.tv_sec = ts.tv_sec;
521: kth->ktr_otv.tv_usec = ts.tv_nsec / 1000;
522: break;
523: case 1:
524: kth->ktr_olid = l->l_lid;
525: kth->ktr_ots.tv_sec = ts.tv_sec;
526: kth->ktr_ots.tv_nsec = ts.tv_nsec;
527: break;
528: case 2:
1.98 christos 529: kth->ktr_lid = l->l_lid;
1.140.2.1 christos 530: kth->ktr_ts.tv_sec = ts.tv_sec;
531: kth->ktr_ts.tv_nsec = ts.tv_nsec;
532: break;
533: default:
534: break;
535: }
1.114 ad 536:
537: *ktep = kte;
538: *bufp = buf;
539:
540: return 0;
1.1 cgd 541: }
542:
1.93 enami 543: void
1.138 dsl 544: ktr_syscall(register_t code, const register_t args[], int narg)
1.1 cgd 545: {
1.125 ad 546: lwp_t *l = curlwp;
1.98 christos 547: struct proc *p = l->l_proc;
1.93 enami 548: struct ktrace_entry *kte;
1.72 darrenr 549: struct ktr_syscall *ktp;
1.17 cgd 550: register_t *argp;
1.57 fvdl 551: size_t len;
1.60 thorpej 552: u_int i;
1.57 fvdl 553:
1.125 ad 554: if (!KTRPOINT(p, KTR_SYSCALL))
555: return;
556:
1.138 dsl 557: len = sizeof(struct ktr_syscall) + narg * sizeof argp[0];
1.1 cgd 558:
1.114 ad 559: if (ktealloc(&kte, (void *)&ktp, l, KTR_SYSCALL, len))
560: return;
1.93 enami 561:
1.138 dsl 562: ktp->ktr_code = code;
563: ktp->ktr_argsize = narg * sizeof argp[0];
1.93 enami 564: argp = (register_t *)(ktp + 1);
1.138 dsl 565: for (i = 0; i < narg; i++)
1.1 cgd 566: *argp++ = args[i];
1.93 enami 567:
1.98 christos 568: ktraddentry(l, kte, KTA_WAITOK);
1.1 cgd 569: }
570:
1.93 enami 571: void
1.125 ad 572: ktr_sysret(register_t code, int error, register_t *retval)
1.1 cgd 573: {
1.125 ad 574: lwp_t *l = curlwp;
1.93 enami 575: struct ktrace_entry *kte;
576: struct ktr_sysret *ktp;
1.1 cgd 577:
1.125 ad 578: if (!KTRPOINT(l->l_proc, KTR_SYSRET))
579: return;
580:
1.114 ad 581: if (ktealloc(&kte, (void *)&ktp, l, KTR_SYSRET,
582: sizeof(struct ktr_sysret)))
583: return;
1.93 enami 584:
585: ktp->ktr_code = code;
586: ktp->ktr_eosys = 0; /* XXX unused */
587: ktp->ktr_error = error;
588: ktp->ktr_retval = retval ? retval[0] : 0;
589: ktp->ktr_retval_1 = retval ? retval[1] : 0;
1.1 cgd 590:
1.98 christos 591: ktraddentry(l, kte, KTA_WAITOK);
1.1 cgd 592: }
593:
1.93 enami 594: void
1.125 ad 595: ktr_namei(const char *path, size_t pathlen)
1.122 dsl 596: {
1.125 ad 597: lwp_t *l = curlwp;
598:
599: if (!KTRPOINT(l->l_proc, KTR_NAMEI))
600: return;
601:
602: ktr_kmem(l, KTR_NAMEI, path, pathlen);
1.122 dsl 603: }
604:
605: void
1.125 ad 606: ktr_namei2(const char *eroot, size_t erootlen,
607: const char *path, size_t pathlen)
1.1 cgd 608: {
1.125 ad 609: lwp_t *l = curlwp;
1.122 dsl 610: struct ktrace_entry *kte;
611: void *buf;
1.1 cgd 612:
1.125 ad 613: if (!KTRPOINT(l->l_proc, KTR_NAMEI))
614: return;
615:
1.122 dsl 616: if (ktealloc(&kte, &buf, l, KTR_NAMEI, erootlen + pathlen))
617: return;
618: memcpy(buf, eroot, erootlen);
619: buf = (char *)buf + erootlen;
620: memcpy(buf, path, pathlen);
621: ktraddentry(l, kte, KTA_WAITOK);
1.18 christos 622: }
623:
1.93 enami 624: void
1.125 ad 625: ktr_emul(void)
1.18 christos 626: {
1.125 ad 627: lwp_t *l = curlwp;
1.98 christos 628: const char *emul = l->l_proc->p_emul->e_name;
1.1 cgd 629:
1.125 ad 630: if (!KTRPOINT(l->l_proc, KTR_EMUL))
631: return;
632:
633: ktr_kmem(l, KTR_EMUL, emul, strlen(emul));
1.1 cgd 634: }
635:
1.93 enami 636: void
1.125 ad 637: ktr_execarg(const void *bf, size_t len)
638: {
639: lwp_t *l = curlwp;
640:
641: if (!KTRPOINT(l->l_proc, KTR_EXEC_ARG))
642: return;
643:
644: ktr_kmem(l, KTR_EXEC_ARG, bf, len);
645: }
646:
647: void
648: ktr_execenv(const void *bf, size_t len)
649: {
650: lwp_t *l = curlwp;
651:
652: if (!KTRPOINT(l->l_proc, KTR_EXEC_ENV))
653: return;
654:
655: ktr_kmem(l, KTR_EXEC_ENV, bf, len);
656: }
657:
658: static void
659: ktr_kmem(lwp_t *l, int type, const void *bf, size_t len)
1.75 dsl 660: {
1.93 enami 661: struct ktrace_entry *kte;
1.114 ad 662: void *buf;
1.75 dsl 663:
1.114 ad 664: if (ktealloc(&kte, &buf, l, type, len))
665: return;
666: memcpy(buf, bf, len);
1.98 christos 667: ktraddentry(l, kte, KTA_WAITOK);
1.75 dsl 668: }
669:
1.125 ad 670: static void
671: ktr_io(lwp_t *l, int fd, enum uio_rw rw, struct iovec *iov, size_t len)
1.1 cgd 672: {
1.93 enami 673: struct ktrace_entry *kte;
1.28 christos 674: struct ktr_genio *ktp;
1.125 ad 675: size_t resid = len, cnt, buflen;
1.118 christos 676: void *cp;
1.39 thorpej 677:
1.114 ad 678: next:
1.93 enami 679: buflen = min(PAGE_SIZE, resid + sizeof(struct ktr_genio));
1.39 thorpej 680:
1.114 ad 681: if (ktealloc(&kte, (void *)&ktp, l, KTR_GENIO, buflen))
682: return;
1.93 enami 683:
1.1 cgd 684: ktp->ktr_fd = fd;
685: ktp->ktr_rw = rw;
1.39 thorpej 686:
1.118 christos 687: cp = (void *)(ktp + 1);
1.39 thorpej 688: buflen -= sizeof(struct ktr_genio);
1.114 ad 689: kte->kte_kth.ktr_len = sizeof(struct ktr_genio);
1.93 enami 690:
691: while (buflen > 0) {
692: cnt = min(iov->iov_len, buflen);
693: if (copyin(iov->iov_base, cp, cnt) != 0)
694: goto out;
1.114 ad 695: kte->kte_kth.ktr_len += cnt;
1.93 enami 696: buflen -= cnt;
697: resid -= cnt;
698: iov->iov_len -= cnt;
699: if (iov->iov_len == 0)
700: iov++;
701: else
1.118 christos 702: iov->iov_base = (char *)iov->iov_base + cnt;
1.93 enami 703: }
1.39 thorpej 704:
1.93 enami 705: /*
706: * Don't push so many entry at once. It will cause kmem map
707: * shortage.
708: */
1.98 christos 709: ktraddentry(l, kte, KTA_WAITOK | KTA_LARGE);
1.93 enami 710: if (resid > 0) {
1.114 ad 711: if (curcpu()->ci_schedstate.spc_flags & SPCF_SHOULDYIELD) {
712: (void)ktrenter(l);
713: preempt();
714: ktrexit(l);
715: }
1.39 thorpej 716:
1.93 enami 717: goto next;
718: }
1.39 thorpej 719:
1.93 enami 720: return;
1.39 thorpej 721:
1.93 enami 722: out:
723: ktefree(kte);
1.114 ad 724: ktrexit(l);
1.1 cgd 725: }
726:
1.93 enami 727: void
1.125 ad 728: ktr_genio(int fd, enum uio_rw rw, const void *addr, size_t len, int error)
729: {
730: lwp_t *l = curlwp;
731: struct iovec iov;
732:
733: if (!KTRPOINT(l->l_proc, KTR_GENIO) || error != 0)
734: return;
735: iov.iov_base = __UNCONST(addr);
736: iov.iov_len = len;
737: ktr_io(l, fd, rw, &iov, len);
738: }
739:
740: void
741: ktr_geniov(int fd, enum uio_rw rw, struct iovec *iov, size_t len, int error)
742: {
743: lwp_t *l = curlwp;
744:
745: if (!KTRPOINT(l->l_proc, KTR_GENIO) || error != 0)
746: return;
747: ktr_io(l, fd, rw, iov, len);
748: }
749:
750: void
751: ktr_mibio(int fd, enum uio_rw rw, const void *addr, size_t len, int error)
752: {
753: lwp_t *l = curlwp;
754: struct iovec iov;
755:
756: if (!KTRPOINT(l->l_proc, KTR_MIB) || error != 0)
757: return;
758: iov.iov_base = __UNCONST(addr);
759: iov.iov_len = len;
760: ktr_io(l, fd, rw, &iov, len);
761: }
762:
763: void
764: ktr_psig(int sig, sig_t action, const sigset_t *mask,
765: const ksiginfo_t *ksi)
1.1 cgd 766: {
1.93 enami 767: struct ktrace_entry *kte;
1.125 ad 768: lwp_t *l = curlwp;
1.78 christos 769: struct {
770: struct ktr_psig kp;
771: siginfo_t si;
1.93 enami 772: } *kbuf;
1.1 cgd 773:
1.125 ad 774: if (!KTRPOINT(l->l_proc, KTR_PSIG))
775: return;
776:
1.114 ad 777: if (ktealloc(&kte, (void *)&kbuf, l, KTR_PSIG, sizeof(*kbuf)))
778: return;
1.93 enami 779:
780: kbuf->kp.signo = (char)sig;
781: kbuf->kp.action = action;
782: kbuf->kp.mask = *mask;
1.114 ad 783:
1.78 christos 784: if (ksi) {
1.93 enami 785: kbuf->kp.code = KSI_TRAPCODE(ksi);
786: (void)memset(&kbuf->si, 0, sizeof(kbuf->si));
787: kbuf->si._info = ksi->ksi_info;
1.114 ad 788: kte->kte_kth.ktr_len = sizeof(*kbuf);
1.78 christos 789: } else {
1.93 enami 790: kbuf->kp.code = 0;
1.114 ad 791: kte->kte_kth.ktr_len = sizeof(struct ktr_psig);
1.78 christos 792: }
1.93 enami 793:
1.98 christos 794: ktraddentry(l, kte, KTA_WAITOK);
1.9 cgd 795: }
796:
1.93 enami 797: void
1.125 ad 798: ktr_csw(int out, int user)
1.9 cgd 799: {
1.125 ad 800: lwp_t *l = curlwp;
1.98 christos 801: struct proc *p = l->l_proc;
1.93 enami 802: struct ktrace_entry *kte;
803: struct ktr_csw *kc;
1.9 cgd 804:
1.125 ad 805: if (!KTRPOINT(p, KTR_CSW))
806: return;
807:
1.114 ad 808: /*
809: * Don't record context switches resulting from blocking on
810: * locks; it's too easy to get duff results.
811: */
1.117 yamt 812: if (l->l_syncobj == &mutex_syncobj || l->l_syncobj == &rw_syncobj)
1.114 ad 813: return;
1.9 cgd 814:
1.93 enami 815: /*
816: * We can't sleep if we're already going to sleep (if original
817: * condition is met during sleep, we hang up).
1.114 ad 818: *
819: * XXX This is not ideal: it would be better to maintain a pool
820: * of ktes and actually push this to the kthread when context
821: * switch happens, however given the points where we are called
822: * from that is difficult to do.
1.93 enami 823: */
1.114 ad 824: if (out) {
1.140.2.1 christos 825: struct timespec ts;
1.114 ad 826: if (ktrenter(l))
827: return;
828:
1.140.2.1 christos 829: nanotime(&l->l_ktrcsw);
830: l->l_pflag |= LP_KTRCSW;
831: nanotime(&ts);
1.114 ad 832: if (user)
833: l->l_pflag |= LP_KTRCSWUSER;
834: else
835: l->l_pflag &= ~LP_KTRCSWUSER;
836:
837: ktrexit(l);
838: return;
1.93 enami 839: }
840:
1.114 ad 841: /*
842: * On the way back in, we need to record twice: once for entry, and
843: * once for exit.
844: */
845: if ((l->l_pflag & LP_KTRCSW) != 0) {
1.140.2.1 christos 846: struct timespec *ts;
1.114 ad 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:
1.140.2.1 christos 855: ts = &l->l_ktrcsw;
1.114 ad 856: switch (KTRFAC_VERSION(p->p_traceflag)) {
857: case 0:
1.140.2.1 christos 858: kte->kte_kth.ktr_otv.tv_sec = ts->tv_sec;
859: kte->kte_kth.ktr_otv.tv_usec = ts->tv_nsec / 1000;
1.114 ad 860: break;
1.140.2.1 christos 861: case 1:
862: kte->kte_kth.ktr_ots.tv_sec = ts->tv_sec;
863: kte->kte_kth.ktr_ots.tv_nsec = ts->tv_nsec;
864: break;
865: case 2:
866: kte->kte_kth.ktr_ts.tv_sec = ts->tv_sec;
867: kte->kte_kth.ktr_ts.tv_nsec = ts->tv_nsec;
868: break;
1.114 ad 869: default:
1.140.2.1 christos 870: break;
1.114 ad 871: }
872:
873: ktraddentry(l, kte, KTA_WAITOK);
1.93 enami 874: }
1.114 ad 875:
876: if (ktealloc(&kte, (void *)&kc, l, KTR_CSW, sizeof(*kc)))
877: return;
878:
879: kc->out = 0;
1.93 enami 880: kc->user = user;
881:
1.114 ad 882: ktraddentry(l, kte, KTA_WAITOK);
1.1 cgd 883: }
884:
1.125 ad 885: bool
1.126 dsl 886: ktr_point(int fac_bit)
1.125 ad 887: {
1.126 dsl 888: return curlwp->l_proc->p_traceflag & fac_bit;
1.125 ad 889: }
890:
1.110 christos 891: int
1.125 ad 892: ktruser(const char *id, void *addr, size_t len, int ustr)
1.51 jdolecek 893: {
1.93 enami 894: struct ktrace_entry *kte;
1.51 jdolecek 895: struct ktr_user *ktp;
1.125 ad 896: lwp_t *l = curlwp;
1.118 christos 897: void *user_dta;
1.110 christos 898: int error;
899:
1.125 ad 900: if (!KTRPOINT(l->l_proc, KTR_USER))
901: return 0;
902:
1.110 christos 903: if (len > KTR_USER_MAXLEN)
904: return ENOSPC;
1.51 jdolecek 905:
1.114 ad 906: error = ktealloc(&kte, (void *)&ktp, l, KTR_USER, sizeof(*ktp) + len);
907: if (error != 0)
908: return error;
1.93 enami 909:
1.51 jdolecek 910: if (ustr) {
911: if (copyinstr(id, ktp->ktr_id, KTR_USER_MAXIDLEN, NULL) != 0)
912: ktp->ktr_id[0] = '\0';
913: } else
914: strncpy(ktp->ktr_id, id, KTR_USER_MAXIDLEN);
915: ktp->ktr_id[KTR_USER_MAXIDLEN-1] = '\0';
916:
1.118 christos 917: user_dta = (void *)(ktp + 1);
1.110 christos 918: if ((error = copyin(addr, (void *)user_dta, len)) != 0)
1.51 jdolecek 919: len = 0;
920:
1.98 christos 921: ktraddentry(l, kte, KTA_WAITOK);
1.110 christos 922: return error;
1.51 jdolecek 923: }
924:
1.93 enami 925: void
1.125 ad 926: ktr_kuser(const char *id, void *addr, size_t len)
1.123 dsl 927: {
928: struct ktrace_entry *kte;
929: struct ktr_user *ktp;
1.125 ad 930: lwp_t *l = curlwp;
1.123 dsl 931: int error;
932:
1.125 ad 933: if (!KTRPOINT(l->l_proc, KTR_USER))
934: return;
935:
1.123 dsl 936: if (len > KTR_USER_MAXLEN)
937: return;
938:
939: error = ktealloc(&kte, (void *)&ktp, l, KTR_USER, sizeof(*ktp) + len);
940: if (error != 0)
941: return;
942:
943: strlcpy(ktp->ktr_id, id, KTR_USER_MAXIDLEN);
944:
945: memcpy(ktp + 1, addr, len);
946:
947: ktraddentry(l, kte, KTA_WAITOK);
948: }
949:
950: void
1.125 ad 951: ktr_mmsg(const void *msgh, size_t size)
1.62 manu 952: {
1.125 ad 953: lwp_t *l = curlwp;
954:
955: if (!KTRPOINT(l->l_proc, KTR_MMSG))
956: return;
957:
958: ktr_kmem(l, KTR_MMSG, msgh, size);
1.62 manu 959: }
1.83 manu 960:
1.93 enami 961: void
1.125 ad 962: ktr_mool(const void *kaddr, size_t size, const void *uaddr)
1.83 manu 963: {
1.93 enami 964: struct ktrace_entry *kte;
1.83 manu 965: struct ktr_mool *kp;
1.97 christos 966: struct ktr_mool *bf;
1.125 ad 967: lwp_t *l = curlwp;
968:
969: if (!KTRPOINT(l->l_proc, KTR_MOOL))
970: return;
1.83 manu 971:
1.114 ad 972: if (ktealloc(&kte, (void *)&kp, l, KTR_MOOL, size + sizeof(*kp)))
973: return;
1.83 manu 974:
975: kp->uaddr = uaddr;
976: kp->size = size;
1.97 christos 977: bf = kp + 1; /* Skip uaddr and size */
978: (void)memcpy(bf, kaddr, size);
1.88 enami 979:
1.98 christos 980: ktraddentry(l, kte, KTA_WAITOK);
1.83 manu 981: }
982:
1.98 christos 983: void
1.140.2.2! christos 984: ktr_saupcall(struct lwp *l, int type, int nevent, int nint, void *sas,
! 985: void *ap, void *ksas)
! 986: {
! 987: struct ktrace_entry *kte;
! 988: struct ktr_saupcall *ktp;
! 989: size_t len, sz;
! 990: struct sa_t **sapp;
! 991: int i;
! 992:
! 993: if (!KTRPOINT(l->l_proc, KTR_SAUPCALL))
! 994: return;
! 995:
! 996: len = sizeof(struct ktr_saupcall);
! 997: sz = len + sizeof(struct sa_t) * (nevent + nint + 1);
! 998:
! 999: if (ktealloc(&kte, (void *)&ktp, l, KTR_SAUPCALL, sz))
! 1000: return;
! 1001:
! 1002: ktp->ktr_type = type;
! 1003: ktp->ktr_nevent = nevent;
! 1004: ktp->ktr_nint = nint;
! 1005: ktp->ktr_sas = sas;
! 1006: ktp->ktr_ap = ap;
! 1007:
! 1008: /* Copy the sa_t's */
! 1009: sapp = (struct sa_t **) ksas;
! 1010:
! 1011: for (i = nevent + nint; i >= 0; i--) {
! 1012: memcpy((char *)ktp + len, *sapp, sizeof(struct sa_t));
! 1013: len += sizeof(struct sa_t);
! 1014: sapp++;
! 1015: }
! 1016:
! 1017: kte->kte_kth.ktr_len = len;
! 1018: ktraddentry(l, kte, KTA_WAITOK);
! 1019: }
! 1020:
! 1021: void
1.125 ad 1022: ktr_mib(const int *name, u_int namelen)
1.98 christos 1023: {
1024: struct ktrace_entry *kte;
1.106 manu 1025: int *namep;
1026: size_t size;
1.125 ad 1027: lwp_t *l = curlwp;
1028:
1029: if (!KTRPOINT(l->l_proc, KTR_MIB))
1030: return;
1.106 manu 1031:
1.114 ad 1032: size = namelen * sizeof(*name);
1033:
1034: if (ktealloc(&kte, (void *)&namep, l, KTR_MIB, size))
1035: return;
1.106 manu 1036:
1037: (void)memcpy(namep, name, namelen * sizeof(*name));
1038:
1039: ktraddentry(l, kte, KTA_WAITOK);
1040: }
1041:
1.1 cgd 1042: /* Interface and common routines */
1043:
1.17 cgd 1044: int
1.140 ad 1045: ktrace_common(lwp_t *curl, int ops, int facs, int pid, file_t *fp)
1.28 christos 1046: {
1.105 ad 1047: struct proc *curp;
1.93 enami 1048: struct proc *p;
1049: struct pgrp *pg;
1050: struct ktr_desc *ktd = NULL;
1.74 fvdl 1051: int ret = 0;
1.72 darrenr 1052: int error = 0;
1.42 sommerfe 1053: int descend;
1.28 christos 1054:
1.105 ad 1055: curp = curl->l_proc;
1.42 sommerfe 1056: descend = ops & KTRFLAG_DESCEND;
1.136 elad 1057: facs = facs & ~((unsigned) KTRFAC_PERSISTENT);
1.28 christos 1058:
1.114 ad 1059: (void)ktrenter(curl);
1060:
1.93 enami 1061: switch (KTROP(ops)) {
1062:
1063: case KTROP_CLEARFILE:
1064: /*
1065: * Clear all uses of the tracefile
1066: */
1.125 ad 1067: mutex_enter(&ktrace_lock);
1.93 enami 1068: ktd = ktd_lookup(fp);
1.125 ad 1069: mutex_exit(&ktrace_lock);
1.93 enami 1070: if (ktd == NULL)
1071: goto done;
1.114 ad 1072: error = ktrderefall(ktd, 1);
1.28 christos 1073: goto done;
1.42 sommerfe 1074:
1.93 enami 1075: case KTROP_SET:
1.125 ad 1076: mutex_enter(&ktrace_lock);
1.93 enami 1077: ktd = ktd_lookup(fp);
1.125 ad 1078: mutex_exit(&ktrace_lock);
1.93 enami 1079: if (ktd == NULL) {
1.114 ad 1080: ktd = kmem_alloc(sizeof(*ktd), KM_SLEEP);
1.93 enami 1081: TAILQ_INIT(&ktd->ktd_queue);
1.133 ad 1082: callout_init(&ktd->ktd_wakch, CALLOUT_MPSAFE);
1.114 ad 1083: cv_init(&ktd->ktd_cv, "ktrwait");
1084: cv_init(&ktd->ktd_sync_cv, "ktrsync");
1.125 ad 1085: ktd->ktd_flags = 0;
1086: ktd->ktd_qcount = 0;
1087: ktd->ktd_error = 0;
1088: ktd->ktd_errcnt = 0;
1.93 enami 1089: ktd->ktd_delayqcnt = ktd_delayqcnt;
1090: ktd->ktd_wakedelay = mstohz(ktd_wakedelay);
1091: ktd->ktd_intrwakdl = mstohz(ktd_intrwakdl);
1.125 ad 1092: ktd->ktd_ref = 0;
1.140 ad 1093: ktd->ktd_fp = fp;
1.125 ad 1094: mutex_enter(&ktrace_lock);
1095: ktdref(ktd);
1096: mutex_exit(&ktrace_lock);
1097:
1.93 enami 1098: /*
1099: * XXX: not correct. needs an way to detect
1100: * whether ktruss or ktrace.
1101: */
1102: if (fp->f_type == DTYPE_PIPE)
1103: ktd->ktd_flags |= KTDF_INTERACTIVE;
1104:
1.140 ad 1105: mutex_enter(&fp->f_lock);
1106: fp->f_count++;
1107: mutex_exit(&fp->f_lock);
1.133 ad 1108: error = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL,
1.124 ad 1109: ktrace_thread, ktd, &ktd->ktd_lwp, "ktrace");
1.93 enami 1110: if (error != 0) {
1.114 ad 1111: kmem_free(ktd, sizeof(*ktd));
1.140 ad 1112: mutex_enter(&fp->f_lock);
1113: fp->f_count--;
1114: mutex_exit(&fp->f_lock);
1.93 enami 1115: goto done;
1116: }
1117:
1.125 ad 1118: mutex_enter(&ktrace_lock);
1.114 ad 1119: if (ktd_lookup(fp) != NULL) {
1120: ktdrel(ktd);
1121: ktd = NULL;
1122: } else
1123: TAILQ_INSERT_TAIL(&ktdq, ktd, ktd_list);
1.124 ad 1124: if (ktd == NULL)
1.125 ad 1125: cv_wait(&lbolt, &ktrace_lock);
1126: mutex_exit(&ktrace_lock);
1.124 ad 1127: if (ktd == NULL)
1.114 ad 1128: goto done;
1.93 enami 1129: }
1130: break;
1.42 sommerfe 1131:
1.93 enami 1132: case KTROP_CLEAR:
1133: break;
1.43 sommerfe 1134: }
1.88 enami 1135:
1.28 christos 1136: /*
1137: * need something to (un)trace (XXX - why is this here?)
1138: */
1139: if (!facs) {
1140: error = EINVAL;
1141: goto done;
1142: }
1.93 enami 1143:
1.88 enami 1144: /*
1.28 christos 1145: * do it
1146: */
1.140.2.2! christos 1147: mutex_enter(proc_lock);
1.42 sommerfe 1148: if (pid < 0) {
1.28 christos 1149: /*
1150: * by process group
1151: */
1.114 ad 1152: pg = pg_find(-pid, PFIND_LOCKED);
1153: if (pg == NULL)
1.28 christos 1154: error = ESRCH;
1.114 ad 1155: else {
1156: LIST_FOREACH(p, &pg->pg_members, p_pglist) {
1157: if (descend)
1158: ret |= ktrsetchildren(curl, p, ops,
1159: facs, ktd);
1160: else
1161: ret |= ktrops(curl, p, ops, facs,
1162: ktd);
1163: }
1.39 thorpej 1164: }
1.88 enami 1165:
1.28 christos 1166: } else {
1167: /*
1168: * by pid
1169: */
1.114 ad 1170: p = p_find(pid, PFIND_LOCKED);
1171: if (p == NULL)
1.28 christos 1172: error = ESRCH;
1.114 ad 1173: else if (descend)
1.105 ad 1174: ret |= ktrsetchildren(curl, p, ops, facs, ktd);
1.28 christos 1175: else
1.105 ad 1176: ret |= ktrops(curl, p, ops, facs, ktd);
1.28 christos 1177: }
1.140.2.2! christos 1178: mutex_exit(proc_lock);
1.114 ad 1179: if (error == 0 && !ret)
1.28 christos 1180: error = EPERM;
1181: done:
1.96 christos 1182: if (ktd != NULL) {
1.125 ad 1183: mutex_enter(&ktrace_lock);
1.96 christos 1184: if (error != 0) {
1185: /*
1186: * Wakeup the thread so that it can be die if we
1187: * can't trace any process.
1188: */
1189: ktd_wakeup(ktd);
1190: }
1.121 ad 1191: if (KTROP(ops) == KTROP_SET || KTROP(ops) == KTROP_CLEARFILE)
1.114 ad 1192: ktdrel(ktd);
1.125 ad 1193: mutex_exit(&ktrace_lock);
1.93 enami 1194: }
1.114 ad 1195: ktrexit(curl);
1.28 christos 1196: return (error);
1197: }
1198:
1199: /*
1.93 enami 1200: * fktrace system call
1.28 christos 1201: */
1202: /* ARGSUSED */
1203: int
1.131 dsl 1204: sys_fktrace(struct lwp *l, const struct sys_fktrace_args *uap, register_t *retval)
1.42 sommerfe 1205: {
1.131 dsl 1206: /* {
1.42 sommerfe 1207: syscallarg(int) fd;
1208: syscallarg(int) ops;
1209: syscallarg(int) facs;
1210: syscallarg(int) pid;
1.131 dsl 1211: } */
1.140 ad 1212: file_t *fp;
1213: int error, fd;
1.42 sommerfe 1214:
1.140 ad 1215: fd = SCARG(uap, fd);
1216: if ((fp = fd_getfile(fd)) == NULL)
1.54 thorpej 1217: return (EBADF);
1218: if ((fp->f_flag & FWRITE) == 0)
1.70 yamt 1219: error = EBADF;
1220: else
1.105 ad 1221: error = ktrace_common(l, SCARG(uap, ops),
1.70 yamt 1222: SCARG(uap, facs), SCARG(uap, pid), fp);
1.140 ad 1223: fd_putfile(fd);
1.70 yamt 1224: return error;
1.42 sommerfe 1225: }
1226:
1227: /*
1228: * ktrace system call
1229: */
1230: /* ARGSUSED */
1231: int
1.131 dsl 1232: sys_ktrace(struct lwp *l, const struct sys_ktrace_args *uap, register_t *retval)
1.19 thorpej 1233: {
1.131 dsl 1234: /* {
1.24 mycroft 1235: syscallarg(const char *) fname;
1.13 cgd 1236: syscallarg(int) ops;
1237: syscallarg(int) facs;
1238: syscallarg(int) pid;
1.131 dsl 1239: } */
1.28 christos 1240: struct vnode *vp = NULL;
1.140 ad 1241: file_t *fp = NULL;
1.98 christos 1242: struct nameidata nd;
1.74 fvdl 1243: int error = 0;
1.98 christos 1244: int fd;
1.1 cgd 1245:
1.114 ad 1246: if (ktrenter(l))
1247: return EAGAIN;
1248:
1.102 christos 1249: if (KTROP(SCARG(uap, ops)) != KTROP_CLEAR) {
1.1 cgd 1250: /*
1251: * an operation which requires a file argument.
1252: */
1.130 pooka 1253: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, fname));
1.22 christos 1254: if ((error = vn_open(&nd, FREAD|FWRITE, 0)) != 0) {
1.114 ad 1255: ktrexit(l);
1.1 cgd 1256: return (error);
1.9 cgd 1257: }
1.1 cgd 1258: vp = nd.ni_vp;
1.25 fvdl 1259: VOP_UNLOCK(vp, 0);
1.1 cgd 1260: if (vp->v_type != VREG) {
1.140 ad 1261: vn_close(vp, FREAD|FWRITE, l->l_cred);
1.114 ad 1262: ktrexit(l);
1.1 cgd 1263: return (EACCES);
1264: }
1265: /*
1.140 ad 1266: * This uses up a file descriptor slot in the
1.42 sommerfe 1267: * tracing process for the duration of this syscall.
1.140 ad 1268: * This is not expected to be a problem.
1.1 cgd 1269: */
1.140 ad 1270: if ((error = fd_allocfile(&fp, &fd)) != 0) {
1271: vn_close(vp, FWRITE, l->l_cred);
1272: ktrexit(l);
1273: return error;
1274: }
1.93 enami 1275: fp->f_flag = FWRITE;
1.42 sommerfe 1276: fp->f_type = DTYPE_VNODE;
1277: fp->f_ops = &vnops;
1.118 christos 1278: fp->f_data = (void *)vp;
1.42 sommerfe 1279: vp = NULL;
1280: }
1.105 ad 1281: error = ktrace_common(l, SCARG(uap, ops), SCARG(uap, facs),
1.42 sommerfe 1282: SCARG(uap, pid), fp);
1283: if (fp != NULL) {
1.140 ad 1284: if (error != 0) {
1285: /* File unused. */
1286: fd_abort(curproc, fp, fd);
1287: } else {
1288: /* File was used. */
1289: fd_abort(curproc, NULL, fd);
1290: }
1.42 sommerfe 1291: }
1.1 cgd 1292: return (error);
1293: }
1294:
1.4 andrew 1295: int
1.125 ad 1296: ktrops(lwp_t *curl, struct proc *p, int ops, int facs,
1.93 enami 1297: struct ktr_desc *ktd)
1.1 cgd 1298: {
1.98 christos 1299: int vers = ops & KTRFAC_VER_MASK;
1.114 ad 1300: int error = 0;
1301:
1.140.2.2! christos 1302: mutex_enter(p->p_lock);
1.125 ad 1303: mutex_enter(&ktrace_lock);
1.98 christos 1304:
1.105 ad 1305: if (!ktrcanset(curl, p))
1.114 ad 1306: goto out;
1.98 christos 1307:
1308: switch (vers) {
1309: case KTRFACv0:
1310: case KTRFACv1:
1.140.2.1 christos 1311: case KTRFACv2:
1.98 christos 1312: break;
1313: default:
1.114 ad 1314: error = EINVAL;
1315: goto out;
1.98 christos 1316: }
1317:
1.28 christos 1318: if (KTROP(ops) == KTROP_SET) {
1.93 enami 1319: if (p->p_tracep != ktd) {
1.1 cgd 1320: /*
1321: * if trace file already in use, relinquish
1322: */
1.28 christos 1323: ktrderef(p);
1.93 enami 1324: p->p_tracep = ktd;
1.28 christos 1325: ktradref(p);
1.1 cgd 1326: }
1327: p->p_traceflag |= facs;
1.137 elad 1328: if (kauth_authorize_process(curl->l_cred, KAUTH_PROCESS_KTRACE,
1329: p, KAUTH_ARG(KAUTH_REQ_PROCESS_KTRACE_PERSISTENT), NULL,
1330: NULL) == 0)
1.136 elad 1331: p->p_traceflag |= KTRFAC_PERSISTENT;
1.88 enami 1332: } else {
1.1 cgd 1333: /* KTROP_CLEAR */
1334: if (((p->p_traceflag &= ~facs) & KTRFAC_MASK) == 0) {
1335: /* no more tracing */
1.28 christos 1336: ktrderef(p);
1.1 cgd 1337: }
1338: }
1.21 christos 1339:
1.98 christos 1340: if (p->p_traceflag)
1341: p->p_traceflag |= vers;
1.21 christos 1342: /*
1343: * Emit an emulation record, every time there is a ktrace
1.88 enami 1344: * change/attach request.
1.21 christos 1345: */
1346: if (KTRPOINT(p, KTR_EMUL))
1.84 dsl 1347: p->p_traceflag |= KTRFAC_TRC_EMUL;
1.139 dsl 1348:
1349: p->p_trace_enabled = trace_is_enabled(p);
1.49 martin 1350: #ifdef __HAVE_SYSCALL_INTERN
1.48 mycroft 1351: (*p->p_emul->e_syscall_intern)(p);
1.49 martin 1352: #endif
1.1 cgd 1353:
1.114 ad 1354: out:
1.125 ad 1355: mutex_exit(&ktrace_lock);
1.140.2.2! christos 1356: mutex_exit(p->p_lock);
1.114 ad 1357:
1.1 cgd 1358: return (1);
1359: }
1360:
1.22 christos 1361: int
1.125 ad 1362: ktrsetchildren(lwp_t *curl, struct proc *top, int ops, int facs,
1.93 enami 1363: struct ktr_desc *ktd)
1.1 cgd 1364: {
1.28 christos 1365: struct proc *p;
1366: int ret = 0;
1.1 cgd 1367:
1.140.2.2! christos 1368: KASSERT(mutex_owned(proc_lock));
1.114 ad 1369:
1.1 cgd 1370: p = top;
1371: for (;;) {
1.105 ad 1372: ret |= ktrops(curl, p, ops, facs, ktd);
1.1 cgd 1373: /*
1374: * If this process has children, descend to them next,
1375: * otherwise do any siblings, and if done with this level,
1376: * follow back up the tree (but not past top).
1377: */
1.82 dsl 1378: if (LIST_FIRST(&p->p_children) != NULL) {
1.39 thorpej 1379: p = LIST_FIRST(&p->p_children);
1.82 dsl 1380: continue;
1381: }
1382: for (;;) {
1.1 cgd 1383: if (p == top)
1384: return (ret);
1.39 thorpej 1385: if (LIST_NEXT(p, p_sibling) != NULL) {
1386: p = LIST_NEXT(p, p_sibling);
1.1 cgd 1387: break;
1388: }
1.12 mycroft 1389: p = p->p_pptr;
1.1 cgd 1390: }
1391: }
1392: /*NOTREACHED*/
1393: }
1394:
1.93 enami 1395: void
1396: ktrwrite(struct ktr_desc *ktd, struct ktrace_entry *kte)
1.1 cgd 1397: {
1.140.2.1 christos 1398: size_t hlen;
1.74 fvdl 1399: struct uio auio;
1.93 enami 1400: struct iovec aiov[64], *iov;
1401: struct ktrace_entry *top = kte;
1402: struct ktr_header *kth;
1.140 ad 1403: file_t *fp = ktd->ktd_fp;
1.93 enami 1404: int error;
1405: next:
1406: auio.uio_iov = iov = &aiov[0];
1.1 cgd 1407: auio.uio_offset = 0;
1408: auio.uio_rw = UIO_WRITE;
1.93 enami 1409: auio.uio_resid = 0;
1410: auio.uio_iovcnt = 0;
1.101 yamt 1411: UIO_SETUP_SYSSPACE(&auio);
1.93 enami 1412: do {
1.140.2.1 christos 1413: struct timespec ts;
1414: lwpid_t lid;
1.93 enami 1415: kth = &kte->kte_kth;
1.98 christos 1416:
1.140.2.1 christos 1417: hlen = sizeof(struct ktr_header);
1418: switch (kth->ktr_version) {
1419: case 0:
1420: ts = kth->ktr_time;
1421:
1422: kth->ktr_otv.tv_sec = ts.tv_sec;
1423: kth->ktr_otv.tv_usec = ts.tv_nsec / 1000;
1.98 christos 1424: kth->ktr_unused = NULL;
1.140.2.1 christos 1425: hlen -= sizeof(kth->_v) -
1426: MAX(sizeof(kth->_v._v0), sizeof(kth->_v._v1));
1427: break;
1428: case 1:
1429: ts = kth->ktr_time;
1430: lid = kth->ktr_lid;
1431:
1432: kth->ktr_ots.tv_sec = ts.tv_sec;
1433: kth->ktr_ots.tv_nsec = ts.tv_nsec;
1434: kth->ktr_olid = lid;
1435: hlen -= sizeof(kth->_v) -
1436: MAX(sizeof(kth->_v._v0), sizeof(kth->_v._v1));
1437: break;
1.98 christos 1438: }
1.118 christos 1439: iov->iov_base = (void *)kth;
1.140.2.1 christos 1440: iov++->iov_len = hlen;
1441: auio.uio_resid += hlen;
1.1 cgd 1442: auio.uio_iovcnt++;
1.93 enami 1443: if (kth->ktr_len > 0) {
1444: iov->iov_base = kte->kte_buf;
1445: iov++->iov_len = kth->ktr_len;
1446: auio.uio_resid += kth->ktr_len;
1447: auio.uio_iovcnt++;
1448: }
1449: } while ((kte = TAILQ_NEXT(kte, kte_list)) != NULL &&
1450: auio.uio_iovcnt < sizeof(aiov) / sizeof(aiov[0]) - 1);
1451:
1452: again:
1453: error = (*fp->f_ops->fo_write)(fp, &fp->f_offset, &auio,
1454: fp->f_cred, FOF_UPDATE_OFFSET);
1455: switch (error) {
1456:
1457: case 0:
1458: if (auio.uio_resid > 0)
1459: goto again;
1460: if (kte != NULL)
1461: goto next;
1462: break;
1463:
1464: case EWOULDBLOCK:
1.116 thorpej 1465: kpause("ktrzzz", false, 1, NULL);
1.93 enami 1466: goto again;
1467:
1468: default:
1469: /*
1470: * If error encountered, give up tracing on this
1471: * vnode. Don't report EPIPE as this can easily
1472: * happen with fktrace()/ktruss.
1473: */
1474: #ifndef DEBUG
1475: if (error != EPIPE)
1476: #endif
1477: log(LOG_NOTICE,
1478: "ktrace write failed, errno %d, tracing stopped\n",
1479: error);
1.114 ad 1480: (void)ktrderefall(ktd, 0);
1.93 enami 1481: }
1482:
1483: while ((kte = top) != NULL) {
1484: top = TAILQ_NEXT(top, kte_list);
1485: ktefree(kte);
1486: }
1487: }
1488:
1489: void
1490: ktrace_thread(void *arg)
1491: {
1492: struct ktr_desc *ktd = arg;
1.140 ad 1493: file_t *fp = ktd->ktd_fp;
1.93 enami 1494: struct ktrace_entry *kte;
1495: int ktrerr, errcnt;
1496:
1.125 ad 1497: mutex_enter(&ktrace_lock);
1.93 enami 1498: for (;;) {
1499: kte = TAILQ_FIRST(&ktd->ktd_queue);
1500: if (kte == NULL) {
1501: if (ktd->ktd_flags & KTDF_WAIT) {
1502: ktd->ktd_flags &= ~(KTDF_WAIT | KTDF_BLOCKING);
1.114 ad 1503: cv_broadcast(&ktd->ktd_sync_cv);
1.93 enami 1504: }
1505: if (ktd->ktd_ref == 0)
1506: break;
1.125 ad 1507: cv_wait(&ktd->ktd_cv, &ktrace_lock);
1.93 enami 1508: continue;
1509: }
1510: TAILQ_INIT(&ktd->ktd_queue);
1511: ktd->ktd_qcount = 0;
1512: ktrerr = ktd->ktd_error;
1513: errcnt = ktd->ktd_errcnt;
1514: ktd->ktd_error = ktd->ktd_errcnt = 0;
1.125 ad 1515: mutex_exit(&ktrace_lock);
1.93 enami 1516:
1517: if (ktrerr) {
1518: log(LOG_NOTICE,
1519: "ktrace failed, fp %p, error 0x%x, total %d\n",
1520: fp, ktrerr, errcnt);
1521: }
1522: ktrwrite(ktd, kte);
1.125 ad 1523: mutex_enter(&ktrace_lock);
1.1 cgd 1524: }
1.93 enami 1525:
1526: TAILQ_REMOVE(&ktdq, ktd, ktd_list);
1.125 ad 1527: mutex_exit(&ktrace_lock);
1.28 christos 1528:
1.1 cgd 1529: /*
1.93 enami 1530: * ktrace file descriptor can't be watched (are not visible to
1531: * userspace), so no kqueue stuff here
1532: * XXX: The above comment is wrong, because the fktrace file
1533: * descriptor is available in userland.
1.1 cgd 1534: */
1.140 ad 1535: closef(fp);
1.93 enami 1536:
1.140.2.2! christos 1537: cv_destroy(&ktd->ktd_sync_cv);
! 1538: cv_destroy(&ktd->ktd_cv);
! 1539:
1.93 enami 1540: callout_stop(&ktd->ktd_wakch);
1.124 ad 1541: callout_destroy(&ktd->ktd_wakch);
1.114 ad 1542: kmem_free(ktd, sizeof(*ktd));
1.39 thorpej 1543:
1.93 enami 1544: kthread_exit(0);
1.1 cgd 1545: }
1546:
1547: /*
1548: * Return true if caller has permission to set the ktracing state
1549: * of target. Essentially, the target can't possess any
1.136 elad 1550: * more permissions than the caller. KTRFAC_PERSISTENT signifies that
1551: * the tracing will persist on sugid processes during exec; it is only
1552: * settable by a process with appropriate credentials.
1.1 cgd 1553: *
1554: * TODO: check groups. use caller effective gid.
1555: */
1.22 christos 1556: int
1.125 ad 1557: ktrcanset(lwp_t *calll, struct proc *targetp)
1.1 cgd 1558: {
1.140.2.2! christos 1559: KASSERT(mutex_owned(targetp->p_lock));
1.125 ad 1560: KASSERT(mutex_owned(&ktrace_lock));
1.114 ad 1561:
1.135 elad 1562: if (kauth_authorize_process(calll->l_cred, KAUTH_PROCESS_KTRACE,
1.112 elad 1563: targetp, NULL, NULL, NULL) == 0)
1.1 cgd 1564: return (1);
1565:
1566: return (0);
1567: }
1.51 jdolecek 1568:
1569: /*
1570: * Put user defined entry to ktrace records.
1571: */
1572: int
1.131 dsl 1573: sys_utrace(struct lwp *l, const struct sys_utrace_args *uap, register_t *retval)
1.51 jdolecek 1574: {
1.131 dsl 1575: /* {
1.52 jdolecek 1576: syscallarg(const char *) label;
1.51 jdolecek 1577: syscallarg(void *) addr;
1578: syscallarg(size_t) len;
1.131 dsl 1579: } */
1.53 jdolecek 1580:
1.125 ad 1581: return ktruser(SCARG(uap, label), SCARG(uap, addr),
1.110 christos 1582: SCARG(uap, len), 1);
1.51 jdolecek 1583: }
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to kern_ktrace.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / kern