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