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