xref: /dragonfly/sys/kern/kern_ktrace.c (revision fb5b3747) 
1 /*
2  * Copyright (c) 1989, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
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  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *	This product includes software developed by the University of
16  *	California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  *	@(#)kern_ktrace.c	8.2 (Berkeley) 9/23/93
34  * $FreeBSD: src/sys/kern/kern_ktrace.c,v 1.35.2.6 2002/07/05 22:36:38 darrenr Exp $
35  * $DragonFly: src/sys/kern/kern_ktrace.c,v 1.30 2008/04/14 12:01:50 dillon Exp $
36  */
37 
38 #include "opt_ktrace.h"
39 
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/sysproto.h>
43 #include <sys/kernel.h>
44 #include <sys/proc.h>
45 #include <sys/fcntl.h>
46 #include <sys/lock.h>
47 #include <sys/nlookup.h>
48 #include <sys/vnode.h>
49 #include <sys/ktrace.h>
50 #include <sys/malloc.h>
51 #include <sys/syslog.h>
52 #include <sys/sysent.h>
53 
54 #include <vm/vm_zone.h>
55 
56 #include <sys/mplock2.h>
57 
58 static MALLOC_DEFINE(M_KTRACE, "KTRACE", "KTRACE");
59 
60 #ifdef KTRACE
61 static struct ktr_header *ktrgetheader (int type);
62 static void ktrwrite (struct lwp *, struct ktr_header *, struct uio *);
63 static int ktrcanset (struct thread *,struct proc *);
64 static int ktrsetchildren (struct thread *,struct proc *,int,int, ktrace_node_t);
65 static int ktrops (struct thread *,struct proc *,int,int, ktrace_node_t);
66 
67 /*
68  * MPSAFE
69  */
70 static struct ktr_header *
71 ktrgetheader(int type)
72 {
73 	struct ktr_header *kth;
74 	struct proc *p = curproc;	/* XXX */
75 	struct lwp *lp = curthread->td_lwp;
76 
77 	MALLOC(kth, struct ktr_header *, sizeof (struct ktr_header),
78 		M_KTRACE, M_WAITOK);
79 	kth->ktr_type = type;
80 	/* XXX threaded flag is a hack at the moment */
81 	kth->ktr_flags = (p->p_nthreads > 1) ? KTRH_THREADED : 0;
82 	microtime(&kth->ktr_time);
83 	kth->ktr_pid = p->p_pid;
84 	kth->ktr_tid = lp->lwp_tid;
85 	bcopy(p->p_comm, kth->ktr_comm, MAXCOMLEN + 1);
86 	return (kth);
87 }
88 
89 void
90 ktrsyscall(struct lwp *lp, int code, int narg, register_t args[])
91 {
92 	struct	ktr_header *kth;
93 	struct	ktr_syscall *ktp;
94 	int len;
95 	register_t *argp;
96 	int i;
97 
98 	len = offsetof(struct ktr_syscall, ktr_args) +
99 	      (narg * sizeof(register_t));
100 
101 	/*
102 	 * Setting the active bit prevents a ktrace recursion from the
103 	 * ktracing op itself.
104 	 */
105 	lp->lwp_traceflag |= KTRFAC_ACTIVE;
106 	kth = ktrgetheader(KTR_SYSCALL);
107 	MALLOC(ktp, struct ktr_syscall *, len, M_KTRACE, M_WAITOK);
108 	ktp->ktr_code = code;
109 	ktp->ktr_narg = narg;
110 	argp = &ktp->ktr_args[0];
111 	for (i = 0; i < narg; i++)
112 		*argp++ = args[i];
113 	kth->ktr_buf = (caddr_t)ktp;
114 	kth->ktr_len = len;
115 	ktrwrite(lp, kth, NULL);
116 	FREE(ktp, M_KTRACE);
117 	FREE(kth, M_KTRACE);
118 	lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
119 }
120 
121 void
122 ktrsysret(struct lwp *lp, int code, int error, register_t retval)
123 {
124 	struct ktr_header *kth;
125 	struct ktr_sysret ktp;
126 
127 	lp->lwp_traceflag |= KTRFAC_ACTIVE;
128 	kth = ktrgetheader(KTR_SYSRET);
129 	ktp.ktr_code = code;
130 	ktp.ktr_error = error;
131 	ktp.ktr_retval = retval;		/* what about val2 ? */
132 
133 	kth->ktr_buf = (caddr_t)&ktp;
134 	kth->ktr_len = sizeof(struct ktr_sysret);
135 
136 	ktrwrite(lp, kth, NULL);
137 	FREE(kth, M_KTRACE);
138 	lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
139 }
140 
141 void
142 ktrnamei(struct lwp *lp, char *path)
143 {
144 	struct ktr_header *kth;
145 
146 	lp->lwp_traceflag |= KTRFAC_ACTIVE;
147 	kth = ktrgetheader(KTR_NAMEI);
148 	kth->ktr_len = strlen(path);
149 	kth->ktr_buf = path;
150 
151 	ktrwrite(lp, kth, NULL);
152 	FREE(kth, M_KTRACE);
153 	lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
154 }
155 
156 void
157 ktrgenio(struct lwp *lp, int fd, enum uio_rw rw, struct uio *uio, int error)
158 {
159 	struct ktr_header *kth;
160 	struct ktr_genio ktg;
161 
162 	if (error)
163 		return;
164 	lp->lwp_traceflag |= KTRFAC_ACTIVE;
165 	kth = ktrgetheader(KTR_GENIO);
166 	ktg.ktr_fd = fd;
167 	ktg.ktr_rw = rw;
168 	kth->ktr_buf = (caddr_t)&ktg;
169 	kth->ktr_len = sizeof(struct ktr_genio);
170 	uio->uio_offset = 0;
171 	uio->uio_rw = UIO_WRITE;
172 
173 	ktrwrite(lp, kth, uio);
174 	FREE(kth, M_KTRACE);
175 	lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
176 }
177 
178 void
179 ktrpsig(struct lwp *lp, int sig, sig_t action, sigset_t *mask, int code)
180 {
181 	struct ktr_header *kth;
182 	struct ktr_psig	kp;
183 
184 	lp->lwp_traceflag |= KTRFAC_ACTIVE;
185 	kth = ktrgetheader(KTR_PSIG);
186 	kp.signo = (char)sig;
187 	kp.action = action;
188 	kp.mask = *mask;
189 	kp.code = code;
190 	kth->ktr_buf = (caddr_t)&kp;
191 	kth->ktr_len = sizeof (struct ktr_psig);
192 
193 	ktrwrite(lp, kth, NULL);
194 	FREE(kth, M_KTRACE);
195 	lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
196 }
197 
198 void
199 ktrcsw(struct lwp *lp, int out, int user)
200 {
201 	struct ktr_header *kth;
202 	struct	ktr_csw kc;
203 
204 	lp->lwp_traceflag |= KTRFAC_ACTIVE;
205 	kth = ktrgetheader(KTR_CSW);
206 	kc.out = out;
207 	kc.user = user;
208 	kth->ktr_buf = (caddr_t)&kc;
209 	kth->ktr_len = sizeof (struct ktr_csw);
210 
211 	ktrwrite(lp, kth, NULL);
212 	FREE(kth, M_KTRACE);
213 	lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
214 }
215 #endif
216 
217 /* Interface and common routines */
218 
219 #ifdef KTRACE
220 /*
221  * ktrace system call
222  */
223 struct ktrace_clear_info {
224 	ktrace_node_t tracenode;
225 	int rootclear;
226 	int error;
227 };
228 
229 static int ktrace_clear_callback(struct proc *p, void *data);
230 
231 #endif
232 
233 /*
234  * MPALMOSTSAFE
235  */
236 int
237 sys_ktrace(struct ktrace_args *uap)
238 {
239 #ifdef KTRACE
240 	struct ktrace_clear_info info;
241 	struct thread *td = curthread;
242 	struct proc *curp = td->td_proc;
243 	struct proc *p;
244 	struct pgrp *pg;
245 	int facs = uap->facs & ~KTRFAC_ROOT;
246 	int ops = KTROP(uap->ops);
247 	int descend = uap->ops & KTRFLAG_DESCEND;
248 	int ret = 0;
249 	int error = 0;
250 	struct nlookupdata nd;
251 	ktrace_node_t tracenode = NULL;
252 
253 	get_mplock();
254 	curp->p_traceflag |= KTRFAC_ACTIVE;
255 	if (ops != KTROP_CLEAR) {
256 		/*
257 		 * an operation which requires a file argument.
258 		 */
259 		error = nlookup_init(&nd, uap->fname,
260 					UIO_USERSPACE, NLC_LOCKVP);
261 		if (error == 0)
262 			error = vn_open(&nd, NULL, FREAD|FWRITE|O_NOFOLLOW, 0);
263 		if (error == 0 && nd.nl_open_vp->v_type != VREG)
264 			error = EACCES;
265 		if (error) {
266 			curp->p_traceflag &= ~KTRFAC_ACTIVE;
267 			nlookup_done(&nd);
268 			goto done;
269 		}
270 		MALLOC(tracenode, ktrace_node_t, sizeof (struct ktrace_node),
271 		       M_KTRACE, M_WAITOK | M_ZERO);
272 		tracenode->kn_vp = nd.nl_open_vp;
273 		tracenode->kn_refs = 1;
274 		nd.nl_open_vp = NULL;
275 		nlookup_done(&nd);
276 		vn_unlock(tracenode->kn_vp);
277 	}
278 	/*
279 	 * Clear all uses of the tracefile.  Not the most efficient operation
280 	 * in the world.
281 	 */
282 	if (ops == KTROP_CLEARFILE) {
283 		info.tracenode = tracenode;
284 		info.error = 0;
285 		info.rootclear = 0;
286 		allproc_scan(ktrace_clear_callback, &info);
287 		error = info.error;
288 		goto done;
289 	}
290 	/*
291 	 * need something to (un)trace (XXX - why is this here?)
292 	 */
293 	if (!facs) {
294 		error = EINVAL;
295 		goto done;
296 	}
297 	/*
298 	 * do it
299 	 */
300 	if (uap->pid < 0) {
301 		/*
302 		 * By process group.  Process group is referenced, preventing
303 		 * disposal.
304 		 */
305 		pg = pgfind(-uap->pid);
306 		if (pg == NULL) {
307 			error = ESRCH;
308 			goto done;
309 		}
310 		lwkt_gettoken(&pg->pg_token);
311 		LIST_FOREACH(p, &pg->pg_members, p_pglist) {
312 			PHOLD(p);
313 			if (descend)
314 				ret |= ktrsetchildren(td, p, ops, facs, tracenode);
315 			else
316 				ret |= ktrops(td, p, ops, facs, tracenode);
317 			PRELE(p);
318 		}
319 		lwkt_reltoken(&pg->pg_token);
320 		pgrel(pg);
321 	} else {
322 		/*
323 		 * by pid
324 		 */
325 		p = pfind(uap->pid);
326 		if (p == NULL) {
327 			error = ESRCH;
328 			goto done;
329 		}
330 		if (descend)
331 			ret |= ktrsetchildren(td, p, ops, facs, tracenode);
332 		else
333 			ret |= ktrops(td, p, ops, facs, tracenode);
334 		PRELE(p);
335 	}
336 	if (!ret)
337 		error = EPERM;
338 done:
339 	if (tracenode)
340 		ktrdestroy(&tracenode);
341 	curp->p_traceflag &= ~KTRFAC_ACTIVE;
342 	rel_mplock();
343 	return (error);
344 #else
345 	return ENOSYS;
346 #endif
347 }
348 
349 #ifdef KTRACE
350 
351 /*
352  * NOTE: NOT MPSAFE (yet)
353  */
354 static int
355 ktrace_clear_callback(struct proc *p, void *data)
356 {
357 	struct ktrace_clear_info *info = data;
358 
359 	if (p->p_tracenode) {
360 		if (info->rootclear) {
361 			if (p->p_tracenode == info->tracenode) {
362 				ktrdestroy(&p->p_tracenode);
363 				p->p_traceflag = 0;
364 			}
365 		} else {
366 			if (p->p_tracenode->kn_vp == info->tracenode->kn_vp) {
367 				if (ktrcanset(curthread, p)) {
368 					ktrdestroy(&p->p_tracenode);
369 					p->p_traceflag = 0;
370 				} else {
371 					info->error = EPERM;
372 				}
373 			}
374 		}
375 	}
376 	return(0);
377 }
378 
379 #endif
380 
381 /*
382  * utrace system call
383  *
384  * MPALMOSTSAFE
385  */
386 int
387 sys_utrace(struct utrace_args *uap)
388 {
389 #ifdef KTRACE
390 	struct ktr_header *kth;
391 	struct thread *td = curthread;	/* XXX */
392 	caddr_t cp;
393 
394 	if (!KTRPOINT(td, KTR_USER))
395 		return (0);
396 	if (uap->len > KTR_USER_MAXLEN)
397 		return (EINVAL);
398 	td->td_lwp->lwp_traceflag |= KTRFAC_ACTIVE;
399 	kth = ktrgetheader(KTR_USER);
400 	MALLOC(cp, caddr_t, uap->len, M_KTRACE, M_WAITOK);
401 	if (!copyin(uap->addr, cp, uap->len)) {
402 		kth->ktr_buf = cp;
403 		kth->ktr_len = uap->len;
404 		ktrwrite(td->td_lwp, kth, NULL);
405 	}
406 	FREE(kth, M_KTRACE);
407 	FREE(cp, M_KTRACE);
408 	td->td_lwp->lwp_traceflag &= ~KTRFAC_ACTIVE;
409 
410 	return (0);
411 #else
412 	return (ENOSYS);
413 #endif
414 }
415 
416 void
417 ktrdestroy(struct ktrace_node **tracenodep)
418 {
419 	ktrace_node_t tracenode;
420 
421 	if ((tracenode = *tracenodep) != NULL) {
422 		*tracenodep = NULL;
423 		KKASSERT(tracenode->kn_refs > 0);
424 		if (atomic_fetchadd_int(&tracenode->kn_refs, -1) == 1) {
425 			vn_close(tracenode->kn_vp, FREAD|FWRITE);
426 			tracenode->kn_vp = NULL;
427 			FREE(tracenode, M_KTRACE);
428 		}
429 	}
430 }
431 
432 /*
433  * This allows a process to inherit a ref on a tracenode and is also used
434  * as a temporary ref to prevent a tracenode from being destroyed out from
435  * under an active operation.
436  */
437 ktrace_node_t
438 ktrinherit(ktrace_node_t tracenode)
439 {
440 	if (tracenode) {
441 		KKASSERT(tracenode->kn_refs > 0);
442 		atomic_add_int(&tracenode->kn_refs, 1);
443 	}
444 	return(tracenode);
445 }
446 
447 #ifdef KTRACE
448 static int
449 ktrops(struct thread *td, struct proc *p, int ops, int facs,
450        ktrace_node_t tracenode)
451 {
452 	ktrace_node_t oldnode;
453 
454 	if (!ktrcanset(td, p))
455 		return (0);
456 	if (ops == KTROP_SET) {
457 		if ((oldnode = p->p_tracenode) != tracenode) {
458 			p->p_tracenode = ktrinherit(tracenode);
459 			ktrdestroy(&oldnode);
460 		}
461 		p->p_traceflag |= facs;
462 		if (td->td_ucred->cr_uid == 0)
463 			p->p_traceflag |= KTRFAC_ROOT;
464 	} else {
465 		/* KTROP_CLEAR */
466 		if (((p->p_traceflag &= ~facs) & KTRFAC_MASK) == 0) {
467 			/* no more tracing */
468 			p->p_traceflag = 0;
469 			ktrdestroy(&p->p_tracenode);
470 		}
471 	}
472 
473 	return (1);
474 }
475 
476 static int
477 ktrsetchildren(struct thread *td, struct proc *top, int ops, int facs,
478 	       ktrace_node_t tracenode)
479 {
480 	struct proc *p;
481 	struct proc *np;
482 	int ret = 0;
483 
484 	p = top;
485 	PHOLD(p);
486 	lwkt_gettoken(&p->p_token);
487 
488 	for (;;) {
489 		ret |= ktrops(td, p, ops, facs, tracenode);
490 
491 		/*
492 		 * If this process has children, descend to them next,
493 		 * otherwise do any siblings, and if done with this level,
494 		 * follow back up the tree (but not past top).
495 		 */
496 		if ((np = LIST_FIRST(&p->p_children)) != NULL) {
497 			PHOLD(np);
498 		}
499 		while (np == NULL) {
500 			if (p == top)
501 				break;
502 			if ((np = LIST_NEXT(p, p_sibling)) != NULL) {
503 				PHOLD(np);
504 				break;
505 			}
506 
507 			/*
508 			 * recurse up to parent, set p in our inner
509 			 * loop when doing this.  np can be NULL if
510 			 * we race a reparenting to init (thus 'top'
511 			 * is skipped past and never encountered).
512 			 */
513 			np = p->p_pptr;
514 			if (np == NULL)
515 				break;
516 			PHOLD(np);
517 			lwkt_reltoken(&p->p_token);
518 			PRELE(p);
519 			p = np;
520 			lwkt_gettoken(&p->p_token);
521 			np = NULL;
522 		}
523 		lwkt_reltoken(&p->p_token);
524 		PRELE(p);
525 		p = np;
526 		if (p == NULL)
527 			break;
528 		/* Already held, but we need the token too */
529 		lwkt_gettoken(&p->p_token);
530 	}
531 	return (ret);
532 }
533 
534 static void
535 ktrwrite(struct lwp *lp, struct ktr_header *kth, struct uio *uio)
536 {
537 	struct ktrace_clear_info info;
538 	struct uio auio;
539 	struct iovec aiov[2];
540 	int error;
541 	ktrace_node_t tracenode;
542 
543 	/*
544 	 * We have to ref our tracenode to prevent it from being ripped out
545 	 * from under us while we are trying to use it.   p_tracenode can
546 	 * go away at any time if another process gets a write error.
547 	 *
548 	 * XXX not MP safe
549 	 */
550 	if (lp->lwp_proc->p_tracenode == NULL)
551 		return;
552 	tracenode = ktrinherit(lp->lwp_proc->p_tracenode);
553 	auio.uio_iov = &aiov[0];
554 	auio.uio_offset = 0;
555 	auio.uio_segflg = UIO_SYSSPACE;
556 	auio.uio_rw = UIO_WRITE;
557 	aiov[0].iov_base = (caddr_t)kth;
558 	aiov[0].iov_len = sizeof(struct ktr_header);
559 	auio.uio_resid = sizeof(struct ktr_header);
560 	auio.uio_iovcnt = 1;
561 	auio.uio_td = curthread;
562 	if (kth->ktr_len > 0) {
563 		auio.uio_iovcnt++;
564 		aiov[1].iov_base = kth->ktr_buf;
565 		aiov[1].iov_len = kth->ktr_len;
566 		auio.uio_resid += kth->ktr_len;
567 		if (uio != NULL)
568 			kth->ktr_len += uio->uio_resid;
569 	}
570 	vn_lock(tracenode->kn_vp, LK_EXCLUSIVE | LK_RETRY);
571 	error = VOP_WRITE(tracenode->kn_vp, &auio,
572 			  IO_UNIT | IO_APPEND, lp->lwp_thread->td_ucred);
573 	if (error == 0 && uio != NULL) {
574 		error = VOP_WRITE(tracenode->kn_vp, uio,
575 			      IO_UNIT | IO_APPEND, lp->lwp_thread->td_ucred);
576 	}
577 	vn_unlock(tracenode->kn_vp);
578 	if (error) {
579 		/*
580 		 * If an error occured, give up tracing on all processes
581 		 * using this tracenode.  This is not MP safe but is
582 		 * blocking-safe.
583 		 */
584 		log(LOG_NOTICE,
585 		    "ktrace write failed, errno %d, tracing stopped\n", error);
586 		info.tracenode = tracenode;
587 		info.error = 0;
588 		info.rootclear = 1;
589 		allproc_scan(ktrace_clear_callback, &info);
590 	}
591 	ktrdestroy(&tracenode);
592 }
593 
594 /*
595  * Return true if caller has permission to set the ktracing state
596  * of target.  Essentially, the target can't possess any
597  * more permissions than the caller.  KTRFAC_ROOT signifies that
598  * root previously set the tracing status on the target process, and
599  * so, only root may further change it.
600  *
601  * TODO: check groups.  use caller effective gid.
602  */
603 static int
604 ktrcanset(struct thread *calltd, struct proc *targetp)
605 {
606 	struct ucred *caller = calltd->td_ucred;
607 	struct ucred *target = targetp->p_ucred;
608 
609 	if (!PRISON_CHECK(caller, target))
610 		return (0);
611 	if ((caller->cr_uid == target->cr_ruid &&
612 	     target->cr_ruid == target->cr_svuid &&
613 	     caller->cr_rgid == target->cr_rgid &&	/* XXX */
614 	     target->cr_rgid == target->cr_svgid &&
615 	     (targetp->p_traceflag & KTRFAC_ROOT) == 0 &&
616 	     (targetp->p_flag & P_SUGID) == 0) ||
617 	     caller->cr_uid == 0)
618 		return (1);
619 
620 	return (0);
621 }
622 
623 #endif /* KTRACE */
624