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