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