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