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