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