2 * Copyright (c) 1989, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * @(#)kern_ktrace.c 8.2 (Berkeley) 9/23/93
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
35 #include "opt_ktrace.h"
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/fcntl.h>
41 #include <sys/kernel.h>
42 #include <sys/kthread.h>
44 #include <sys/mutex.h>
46 #include <sys/malloc.h>
47 #include <sys/namei.h>
49 #include <sys/unistd.h>
50 #include <sys/vnode.h>
51 #include <sys/ktrace.h>
53 #include <sys/sysctl.h>
54 #include <sys/syslog.h>
55 #include <sys/sysproto.h>
57 static MALLOC_DEFINE(M_KTRACE, "KTRACE", "KTRACE");
61 #ifndef KTRACE_REQUEST_POOL
62 #define KTRACE_REQUEST_POOL 100
66 struct ktr_header ktr_header;
67 struct ucred *ktr_cred;
70 struct ktr_syscall ktr_syscall;
71 struct ktr_sysret ktr_sysret;
72 struct ktr_genio ktr_genio;
73 struct ktr_psig ktr_psig;
74 struct ktr_csw ktr_csw;
76 STAILQ_ENTRY(ktr_request) ktr_list;
79 static int data_lengths[] = {
81 offsetof(struct ktr_syscall, ktr_args), /* KTR_SYSCALL */
82 sizeof(struct ktr_sysret), /* KTR_SYSRET */
84 sizeof(struct ktr_genio), /* KTR_GENIO */
85 sizeof(struct ktr_psig), /* KTR_PSIG */
86 sizeof(struct ktr_csw), /* KTR_CSW */
90 static STAILQ_HEAD(, ktr_request) ktr_todo;
91 static STAILQ_HEAD(, ktr_request) ktr_free;
93 static SYSCTL_NODE(_kern, OID_AUTO, ktrace, CTLFLAG_RD, 0, "KTRACE options");
95 static u_int ktr_requestpool = KTRACE_REQUEST_POOL;
96 TUNABLE_INT("kern.ktrace.request_pool", &ktr_requestpool);
98 static u_int ktr_geniosize = PAGE_SIZE;
99 TUNABLE_INT("kern.ktrace.genio_size", &ktr_geniosize);
100 SYSCTL_UINT(_kern_ktrace, OID_AUTO, genio_size, CTLFLAG_RW, &ktr_geniosize,
101 0, "Maximum size of genio event payload");
103 static int print_message = 1;
104 struct mtx ktrace_mtx;
105 static struct cv ktrace_cv;
107 static void ktrace_init(void *dummy);
108 static int sysctl_kern_ktrace_request_pool(SYSCTL_HANDLER_ARGS);
109 static u_int ktrace_resize_pool(u_int newsize);
110 static struct ktr_request *ktr_getrequest(int type);
111 static void ktr_submitrequest(struct ktr_request *req);
112 static void ktr_freerequest(struct ktr_request *req);
113 static void ktr_loop(void *dummy);
114 static void ktr_writerequest(struct ktr_request *req);
115 static int ktrcanset(struct thread *,struct proc *);
116 static int ktrsetchildren(struct thread *,struct proc *,int,int,struct vnode *);
117 static int ktrops(struct thread *,struct proc *,int,int,struct vnode *);
120 ktrace_init(void *dummy)
122 struct ktr_request *req;
125 mtx_init(&ktrace_mtx, "ktrace", NULL, MTX_DEF | MTX_QUIET);
126 cv_init(&ktrace_cv, "ktrace");
127 STAILQ_INIT(&ktr_todo);
128 STAILQ_INIT(&ktr_free);
129 for (i = 0; i < ktr_requestpool; i++) {
130 req = malloc(sizeof(struct ktr_request), M_KTRACE, M_WAITOK);
131 STAILQ_INSERT_HEAD(&ktr_free, req, ktr_list);
133 kthread_create(ktr_loop, NULL, NULL, RFHIGHPID, 0, "ktrace");
135 SYSINIT(ktrace_init, SI_SUB_KTRACE, SI_ORDER_ANY, ktrace_init, NULL);
138 sysctl_kern_ktrace_request_pool(SYSCTL_HANDLER_ARGS)
141 u_int newsize, oldsize, wantsize;
144 /* Handle easy read-only case first to avoid warnings from GCC. */
146 mtx_lock(&ktrace_mtx);
147 oldsize = ktr_requestpool;
148 mtx_unlock(&ktrace_mtx);
149 return (SYSCTL_OUT(req, &oldsize, sizeof(u_int)));
152 error = SYSCTL_IN(req, &wantsize, sizeof(u_int));
156 td->td_pflags |= TDP_INKTRACE;
157 mtx_lock(&ktrace_mtx);
158 oldsize = ktr_requestpool;
159 newsize = ktrace_resize_pool(wantsize);
160 mtx_unlock(&ktrace_mtx);
161 td->td_pflags &= ~TDP_INKTRACE;
162 error = SYSCTL_OUT(req, &oldsize, sizeof(u_int));
165 if (wantsize > oldsize && newsize < wantsize)
169 SYSCTL_PROC(_kern_ktrace, OID_AUTO, request_pool, CTLTYPE_UINT|CTLFLAG_RW,
170 &ktr_requestpool, 0, sysctl_kern_ktrace_request_pool, "IU", "");
173 ktrace_resize_pool(u_int newsize)
175 struct ktr_request *req;
178 mtx_assert(&ktrace_mtx, MA_OWNED);
180 bound = newsize - ktr_requestpool;
182 return (ktr_requestpool);
184 /* Shrink pool down to newsize if possible. */
185 while (bound++ < 0) {
186 req = STAILQ_FIRST(&ktr_free);
188 return (ktr_requestpool);
189 STAILQ_REMOVE_HEAD(&ktr_free, ktr_list);
191 mtx_unlock(&ktrace_mtx);
193 mtx_lock(&ktrace_mtx);
196 /* Grow pool up to newsize. */
197 while (bound-- > 0) {
198 mtx_unlock(&ktrace_mtx);
199 req = malloc(sizeof(struct ktr_request), M_KTRACE,
201 mtx_lock(&ktrace_mtx);
202 STAILQ_INSERT_HEAD(&ktr_free, req, ktr_list);
205 return (ktr_requestpool);
208 static struct ktr_request *
209 ktr_getrequest(int type)
211 struct ktr_request *req;
212 struct thread *td = curthread;
213 struct proc *p = td->td_proc;
216 td->td_pflags |= TDP_INKTRACE;
217 mtx_lock(&ktrace_mtx);
218 if (!KTRCHECK(td, type)) {
219 mtx_unlock(&ktrace_mtx);
220 td->td_pflags &= ~TDP_INKTRACE;
223 req = STAILQ_FIRST(&ktr_free);
225 STAILQ_REMOVE_HEAD(&ktr_free, ktr_list);
226 req->ktr_header.ktr_type = type;
227 if (p->p_traceflag & KTRFAC_DROP) {
228 req->ktr_header.ktr_type |= KTR_DROP;
229 p->p_traceflag &= ~KTRFAC_DROP;
231 KASSERT(p->p_tracevp != NULL, ("ktrace: no trace vnode"));
232 KASSERT(p->p_tracecred != NULL, ("ktrace: no trace cred"));
233 req->ktr_vp = p->p_tracevp;
235 req->ktr_cred = crhold(p->p_tracecred);
236 mtx_unlock(&ktrace_mtx);
237 microtime(&req->ktr_header.ktr_time);
238 req->ktr_header.ktr_pid = p->p_pid;
239 bcopy(p->p_comm, req->ktr_header.ktr_comm, MAXCOMLEN + 1);
240 req->ktr_header.ktr_buffer = NULL;
241 req->ktr_header.ktr_len = 0;
243 p->p_traceflag |= KTRFAC_DROP;
246 mtx_unlock(&ktrace_mtx);
248 printf("Out of ktrace request objects.\n");
249 td->td_pflags &= ~TDP_INKTRACE;
255 ktr_submitrequest(struct ktr_request *req)
258 mtx_lock(&ktrace_mtx);
259 STAILQ_INSERT_TAIL(&ktr_todo, req, ktr_list);
260 cv_signal(&ktrace_cv);
261 mtx_unlock(&ktrace_mtx);
262 curthread->td_pflags &= ~TDP_INKTRACE;
266 ktr_freerequest(struct ktr_request *req)
269 crfree(req->ktr_cred);
270 if (req->ktr_vp != NULL) {
275 if (req->ktr_header.ktr_buffer != NULL)
276 free(req->ktr_header.ktr_buffer, M_KTRACE);
277 mtx_lock(&ktrace_mtx);
278 STAILQ_INSERT_HEAD(&ktr_free, req, ktr_list);
279 mtx_unlock(&ktrace_mtx);
283 ktr_loop(void *dummy)
285 struct ktr_request *req;
289 /* Only cache these values once. */
293 mtx_lock(&ktrace_mtx);
294 while (STAILQ_EMPTY(&ktr_todo))
295 cv_wait(&ktrace_cv, &ktrace_mtx);
296 req = STAILQ_FIRST(&ktr_todo);
297 STAILQ_REMOVE_HEAD(&ktr_todo, ktr_list);
298 KASSERT(req != NULL, ("got a NULL request"));
299 mtx_unlock(&ktrace_mtx);
301 * It is not enough just to pass the cached cred
302 * to the VOP's in ktr_writerequest(). Some VFS
303 * operations use curthread->td_ucred, so we need
304 * to modify our thread's credentials as well.
307 td->td_ucred = req->ktr_cred;
308 ktr_writerequest(req);
310 ktr_freerequest(req);
318 ktrsyscall(code, narg, args)
322 struct ktr_request *req;
323 struct ktr_syscall *ktp;
327 buflen = sizeof(register_t) * narg;
329 buf = malloc(buflen, M_KTRACE, M_WAITOK);
330 bcopy(args, buf, buflen);
332 req = ktr_getrequest(KTR_SYSCALL);
338 ktp = &req->ktr_data.ktr_syscall;
339 ktp->ktr_code = code;
340 ktp->ktr_narg = narg;
342 req->ktr_header.ktr_len = buflen;
343 req->ktr_header.ktr_buffer = buf;
345 ktr_submitrequest(req);
352 ktrsysret(code, error, retval)
356 struct ktr_request *req;
357 struct ktr_sysret *ktp;
359 req = ktr_getrequest(KTR_SYSRET);
362 ktp = &req->ktr_data.ktr_sysret;
363 ktp->ktr_code = code;
364 ktp->ktr_error = error;
365 ktp->ktr_retval = retval; /* what about val2 ? */
366 ktr_submitrequest(req);
373 struct ktr_request *req;
377 namelen = strlen(path);
379 buf = malloc(namelen, M_KTRACE, M_WAITOK);
380 bcopy(path, buf, namelen);
382 req = ktr_getrequest(KTR_NAMEI);
389 req->ktr_header.ktr_len = namelen;
390 req->ktr_header.ktr_buffer = buf;
392 ktr_submitrequest(req);
396 * Since the uio may not stay valid, we can not hand off this request to
397 * the thread and need to process it synchronously. However, we wish to
398 * keep the relative order of records in a trace file correct, so we
399 * do put this request on the queue (if it isn't empty) and then block.
400 * The ktrace thread waks us back up when it is time for this event to
401 * be posted and blocks until we have completed writing out the event
402 * and woken it back up.
405 ktrgenio(fd, rw, uio, error)
411 struct ktr_request *req;
412 struct ktr_genio *ktg;
421 uio->uio_rw = UIO_WRITE;
422 datalen = imin(uio->uio_resid, ktr_geniosize);
423 buf = malloc(datalen, M_KTRACE, M_WAITOK);
424 error = uiomove(buf, datalen, uio);
430 req = ktr_getrequest(KTR_GENIO);
435 ktg = &req->ktr_data.ktr_genio;
438 req->ktr_header.ktr_len = datalen;
439 req->ktr_header.ktr_buffer = buf;
440 ktr_submitrequest(req);
444 ktrpsig(sig, action, mask, code)
450 struct ktr_request *req;
453 req = ktr_getrequest(KTR_PSIG);
456 kp = &req->ktr_data.ktr_psig;
457 kp->signo = (char)sig;
461 ktr_submitrequest(req);
468 struct ktr_request *req;
471 req = ktr_getrequest(KTR_CSW);
474 kc = &req->ktr_data.ktr_csw;
477 ktr_submitrequest(req);
481 /* Interface and common routines */
488 #ifndef _SYS_SYSPROTO_H_
500 register struct ktrace_args *uap;
503 register struct vnode *vp = NULL;
504 register struct proc *p;
506 int facs = uap->facs & ~KTRFAC_ROOT;
507 int ops = KTROP(uap->ops);
508 int descend = uap->ops & KTRFLAG_DESCEND;
510 int flags, error = 0;
515 * Need something to (un)trace.
517 if (ops != KTROP_CLEARFILE && facs == 0)
520 td->td_pflags |= TDP_INKTRACE;
521 if (ops != KTROP_CLEAR) {
523 * an operation which requires a file argument.
525 NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, uap->fname, td);
526 flags = FREAD | FWRITE | O_NOFOLLOW;
528 error = vn_open(&nd, &flags, 0, -1);
531 td->td_pflags &= ~TDP_INKTRACE;
534 NDFREE(&nd, NDF_ONLY_PNBUF);
536 VOP_UNLOCK(vp, 0, td);
537 if (vp->v_type != VREG) {
538 (void) vn_close(vp, FREAD|FWRITE, td->td_ucred, td);
540 td->td_pflags &= ~TDP_INKTRACE;
546 * Clear all uses of the tracefile.
548 if (ops == KTROP_CLEARFILE) {
549 sx_slock(&allproc_lock);
550 LIST_FOREACH(p, &allproc, p_list) {
552 if (p->p_tracevp == vp) {
553 if (ktrcanset(td, p)) {
554 mtx_lock(&ktrace_mtx);
555 cred = p->p_tracecred;
556 p->p_tracecred = NULL;
559 mtx_unlock(&ktrace_mtx);
562 (void) vn_close(vp, FREAD|FWRITE,
573 sx_sunlock(&allproc_lock);
579 sx_slock(&proctree_lock);
584 pg = pgfind(-uap->pid);
586 sx_sunlock(&proctree_lock);
591 * ktrops() may call vrele(). Lock pg_members
592 * by the proctree_lock rather than pg_mtx.
595 LIST_FOREACH(p, &pg->pg_members, p_pglist)
597 ret |= ktrsetchildren(td, p, ops, facs, vp);
599 ret |= ktrops(td, p, ops, facs, vp);
606 sx_sunlock(&proctree_lock);
610 error = p_cansee(td, p);
612 * The slock of the proctree lock will keep this process
613 * from going away, so unlocking the proc here is ok.
619 ret |= ktrsetchildren(td, p, ops, facs, vp);
621 ret |= ktrops(td, p, ops, facs, vp);
623 sx_sunlock(&proctree_lock);
629 (void) vn_close(vp, FWRITE, td->td_ucred, td);
632 td->td_pflags &= ~TDP_INKTRACE;
648 register struct utrace_args *uap;
652 struct ktr_request *req;
656 if (!KTRPOINT(td, KTR_USER))
658 if (uap->len > KTR_USER_MAXLEN)
660 cp = malloc(uap->len, M_KTRACE, M_WAITOK);
661 error = copyin(uap->addr, cp, uap->len);
666 req = ktr_getrequest(KTR_USER);
671 req->ktr_header.ktr_buffer = cp;
672 req->ktr_header.ktr_len = uap->len;
673 ktr_submitrequest(req);
682 ktrops(td, p, ops, facs, vp)
688 struct vnode *tracevp = NULL;
689 struct ucred *tracecred = NULL;
692 if (!ktrcanset(td, p)) {
696 mtx_lock(&ktrace_mtx);
697 if (ops == KTROP_SET) {
698 if (p->p_tracevp != vp) {
700 * if trace file already in use, relinquish below
702 tracevp = p->p_tracevp;
706 if (p->p_tracecred != td->td_ucred) {
707 tracecred = p->p_tracecred;
708 p->p_tracecred = crhold(td->td_ucred);
710 p->p_traceflag |= facs;
711 if (td->td_ucred->cr_uid == 0)
712 p->p_traceflag |= KTRFAC_ROOT;
715 if (((p->p_traceflag &= ~facs) & KTRFAC_MASK) == 0) {
716 /* no more tracing */
718 tracevp = p->p_tracevp;
720 tracecred = p->p_tracecred;
721 p->p_tracecred = NULL;
724 mtx_unlock(&ktrace_mtx);
726 if (tracevp != NULL) {
731 if (tracecred != NULL)
738 ktrsetchildren(td, top, ops, facs, vp)
744 register struct proc *p;
745 register int ret = 0;
748 sx_assert(&proctree_lock, SX_LOCKED);
750 ret |= ktrops(td, p, ops, facs, vp);
752 * If this process has children, descend to them next,
753 * otherwise do any siblings, and if done with this level,
754 * follow back up the tree (but not past top).
756 if (!LIST_EMPTY(&p->p_children))
757 p = LIST_FIRST(&p->p_children);
761 if (LIST_NEXT(p, p_sibling)) {
762 p = LIST_NEXT(p, p_sibling);
772 ktr_writerequest(struct ktr_request *req)
774 struct ktr_header *kth;
780 struct iovec aiov[3];
782 int datalen, buflen, vrele_count;
787 * If vp is NULL, the vp has been cleared out from under this
788 * request, so just drop it.
792 kth = &req->ktr_header;
793 datalen = data_lengths[(u_short)kth->ktr_type & ~KTR_DROP];
794 buflen = kth->ktr_len;
795 cred = req->ktr_cred;
797 auio.uio_iov = &aiov[0];
799 auio.uio_segflg = UIO_SYSSPACE;
800 auio.uio_rw = UIO_WRITE;
801 aiov[0].iov_base = (caddr_t)kth;
802 aiov[0].iov_len = sizeof(struct ktr_header);
803 auio.uio_resid = sizeof(struct ktr_header);
807 aiov[1].iov_base = (caddr_t)&req->ktr_data;
808 aiov[1].iov_len = datalen;
809 auio.uio_resid += datalen;
811 kth->ktr_len += datalen;
814 KASSERT(kth->ktr_buffer != NULL, ("ktrace: nothing to write"));
815 aiov[auio.uio_iovcnt].iov_base = kth->ktr_buffer;
816 aiov[auio.uio_iovcnt].iov_len = buflen;
817 auio.uio_resid += buflen;
821 vn_start_write(vp, &mp, V_WAIT);
822 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
823 (void)VOP_LEASE(vp, td, cred, LEASE_WRITE);
825 error = mac_check_vnode_write(cred, NOCRED, vp);
828 error = VOP_WRITE(vp, &auio, IO_UNIT | IO_APPEND, cred);
829 VOP_UNLOCK(vp, 0, td);
830 vn_finished_write(mp);
835 * If error encountered, give up tracing on this vnode. We defer
836 * all the vrele()'s on the vnode until after we are finished walking
837 * the various lists to avoid needlessly holding locks.
839 log(LOG_NOTICE, "ktrace write failed, errno %d, tracing stopped\n",
843 * First, clear this vnode from being used by any processes in the
845 * XXX - If one process gets an EPERM writing to the vnode, should
846 * we really do this? Other processes might have suitable
847 * credentials for the operation.
850 sx_slock(&allproc_lock);
851 LIST_FOREACH(p, &allproc, p_list) {
853 if (p->p_tracevp == vp) {
854 mtx_lock(&ktrace_mtx);
857 cred = p->p_tracecred;
858 p->p_tracecred = NULL;
859 mtx_unlock(&ktrace_mtx);
868 sx_sunlock(&allproc_lock);
870 * Second, clear this vnode from any pending requests.
872 mtx_lock(&ktrace_mtx);
873 STAILQ_FOREACH(req, &ktr_todo, ktr_list) {
874 if (req->ktr_vp == vp) {
879 mtx_unlock(&ktrace_mtx);
881 while (vrele_count-- > 0)
887 * Return true if caller has permission to set the ktracing state
888 * of target. Essentially, the target can't possess any
889 * more permissions than the caller. KTRFAC_ROOT signifies that
890 * root previously set the tracing status on the target process, and
891 * so, only root may further change it.
894 ktrcanset(td, targetp)
896 struct proc *targetp;
899 PROC_LOCK_ASSERT(targetp, MA_OWNED);
900 if (targetp->p_traceflag & KTRFAC_ROOT &&
901 suser_cred(td->td_ucred, SUSER_ALLOWJAIL))
904 if (p_candebug(td, targetp) != 0)