1 /* $NetBSD: kern_ktrace.c,v 1.161 2012/02/19 21:06:51 rmind 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.161 2012/02/19 21:06:51 rmind 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] __aligned(sizeof(register_t)); 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 kauth_listener_t ktrace_listener; 182 183 static void 184 ktd_wakeup(struct ktr_desc *ktd) 185 { 186 187 callout_stop(&ktd->ktd_wakch); 188 cv_signal(&ktd->ktd_cv); 189 } 190 191 static void 192 ktd_callout(void *arg) 193 { 194 195 mutex_enter(&ktrace_lock); 196 ktd_wakeup(arg); 197 mutex_exit(&ktrace_lock); 198 } 199 200 static void 201 ktd_logerrl(struct ktr_desc *ktd, int error) 202 { 203 204 ktd->ktd_error |= error; 205 ktd->ktd_errcnt++; 206 } 207 208 #if 0 209 static void 210 ktd_logerr(struct proc *p, int error) 211 { 212 struct ktr_desc *ktd; 213 214 KASSERT(mutex_owned(&ktrace_lock)); 215 216 ktd = p->p_tracep; 217 if (ktd == NULL) 218 return; 219 220 ktd_logerrl(ktd, error); 221 } 222 #endif 223 224 static inline int 225 ktrenter(lwp_t *l) 226 { 227 228 if ((l->l_pflag & LP_KTRACTIVE) != 0) 229 return 1; 230 l->l_pflag |= LP_KTRACTIVE; 231 return 0; 232 } 233 234 static inline void 235 ktrexit(lwp_t *l) 236 { 237 238 l->l_pflag &= ~LP_KTRACTIVE; 239 } 240 241 static int 242 ktrace_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie, 243 void *arg0, void *arg1, void *arg2, void *arg3) 244 { 245 struct proc *p; 246 int result; 247 enum kauth_process_req req; 248 249 result = KAUTH_RESULT_DEFER; 250 p = arg0; 251 252 if (action != KAUTH_PROCESS_KTRACE) 253 return result; 254 255 req = (enum kauth_process_req)(unsigned long)arg1; 256 257 /* Privileged; secmodel should handle these. */ 258 if (req == KAUTH_REQ_PROCESS_KTRACE_PERSISTENT) 259 return result; 260 261 if ((p->p_traceflag & KTRFAC_PERSISTENT) || 262 (p->p_flag & PK_SUGID)) 263 return result; 264 265 if (kauth_cred_geteuid(cred) == kauth_cred_getuid(p->p_cred) && 266 kauth_cred_getuid(cred) == kauth_cred_getsvuid(p->p_cred) && 267 kauth_cred_getgid(cred) == kauth_cred_getgid(p->p_cred) && 268 kauth_cred_getgid(cred) == kauth_cred_getsvgid(p->p_cred)) 269 result = KAUTH_RESULT_ALLOW; 270 271 return result; 272 } 273 274 /* 275 * Initialise the ktrace system. 276 */ 277 void 278 ktrinit(void) 279 { 280 281 mutex_init(&ktrace_lock, MUTEX_DEFAULT, IPL_NONE); 282 kte_cache = pool_cache_init(sizeof(struct ktrace_entry), 0, 0, 0, 283 "ktrace", &pool_allocator_nointr, IPL_NONE, NULL, NULL, NULL); 284 285 ktrace_listener = kauth_listen_scope(KAUTH_SCOPE_PROCESS, 286 ktrace_listener_cb, NULL); 287 } 288 289 /* 290 * Release a reference. Called with ktrace_lock held. 291 */ 292 void 293 ktdrel(struct ktr_desc *ktd) 294 { 295 296 KASSERT(mutex_owned(&ktrace_lock)); 297 298 KDASSERT(ktd->ktd_ref != 0); 299 KASSERT(ktd->ktd_ref > 0); 300 KASSERT(ktrace_on > 0); 301 ktrace_on--; 302 if (--ktd->ktd_ref <= 0) { 303 ktd->ktd_flags |= KTDF_DONE; 304 cv_signal(&ktd->ktd_cv); 305 } 306 } 307 308 void 309 ktdref(struct ktr_desc *ktd) 310 { 311 312 KASSERT(mutex_owned(&ktrace_lock)); 313 314 ktd->ktd_ref++; 315 ktrace_on++; 316 } 317 318 struct ktr_desc * 319 ktd_lookup(file_t *fp) 320 { 321 struct ktr_desc *ktd; 322 323 KASSERT(mutex_owned(&ktrace_lock)); 324 325 for (ktd = TAILQ_FIRST(&ktdq); ktd != NULL; 326 ktd = TAILQ_NEXT(ktd, ktd_list)) { 327 if (ktrsamefile(ktd->ktd_fp, fp)) { 328 ktdref(ktd); 329 break; 330 } 331 } 332 333 return (ktd); 334 } 335 336 void 337 ktraddentry(lwp_t *l, struct ktrace_entry *kte, int flags) 338 { 339 struct proc *p = l->l_proc; 340 struct ktr_desc *ktd; 341 #ifdef DEBUG 342 struct timeval t1, t2; 343 #endif 344 345 mutex_enter(&ktrace_lock); 346 347 if (p->p_traceflag & KTRFAC_TRC_EMUL) { 348 /* Add emulation trace before first entry for this process */ 349 p->p_traceflag &= ~KTRFAC_TRC_EMUL; 350 mutex_exit(&ktrace_lock); 351 ktrexit(l); 352 ktremul(); 353 (void)ktrenter(l); 354 mutex_enter(&ktrace_lock); 355 } 356 357 /* Tracing may have been cancelled. */ 358 ktd = p->p_tracep; 359 if (ktd == NULL) 360 goto freekte; 361 362 /* 363 * Bump reference count so that the object will remain while 364 * we are here. Note that the trace is controlled by other 365 * process. 366 */ 367 ktdref(ktd); 368 369 if (ktd->ktd_flags & KTDF_DONE) 370 goto relktd; 371 372 if (ktd->ktd_qcount > ktd_maxentry) { 373 ktd_logerrl(ktd, KTDE_ENOSPC); 374 goto relktd; 375 } 376 TAILQ_INSERT_TAIL(&ktd->ktd_queue, kte, kte_list); 377 ktd->ktd_qcount++; 378 if (ktd->ktd_flags & KTDF_BLOCKING) 379 goto skip_sync; 380 381 if (flags & KTA_WAITOK && 382 (/* flags & KTA_LARGE */0 || ktd->ktd_flags & KTDF_WAIT || 383 ktd->ktd_qcount > ktd_maxentry >> 1)) 384 /* 385 * Sync with writer thread since we're requesting rather 386 * big one or many requests are pending. 387 */ 388 do { 389 ktd->ktd_flags |= KTDF_WAIT; 390 ktd_wakeup(ktd); 391 #ifdef DEBUG 392 getmicrouptime(&t1); 393 #endif 394 if (cv_timedwait(&ktd->ktd_sync_cv, &ktrace_lock, 395 ktd_timeout * hz) != 0) { 396 ktd->ktd_flags |= KTDF_BLOCKING; 397 /* 398 * Maybe the writer thread is blocking 399 * completely for some reason, but 400 * don't stop target process forever. 401 */ 402 log(LOG_NOTICE, "ktrace timeout\n"); 403 break; 404 } 405 #ifdef DEBUG 406 getmicrouptime(&t2); 407 timersub(&t2, &t1, &t2); 408 if (t2.tv_sec > 0) 409 log(LOG_NOTICE, 410 "ktrace long wait: %lld.%06ld\n", 411 (long long)t2.tv_sec, (long)t2.tv_usec); 412 #endif 413 } while (p->p_tracep == ktd && 414 (ktd->ktd_flags & (KTDF_WAIT | KTDF_DONE)) == KTDF_WAIT); 415 else { 416 /* Schedule delayed wakeup */ 417 if (ktd->ktd_qcount > ktd->ktd_delayqcnt) 418 ktd_wakeup(ktd); /* Wakeup now */ 419 else if (!callout_pending(&ktd->ktd_wakch)) 420 callout_reset(&ktd->ktd_wakch, 421 ktd->ktd_flags & KTDF_INTERACTIVE ? 422 ktd->ktd_intrwakdl : ktd->ktd_wakedelay, 423 ktd_callout, ktd); 424 } 425 426 skip_sync: 427 ktdrel(ktd); 428 mutex_exit(&ktrace_lock); 429 ktrexit(l); 430 return; 431 432 relktd: 433 ktdrel(ktd); 434 435 freekte: 436 mutex_exit(&ktrace_lock); 437 ktefree(kte); 438 ktrexit(l); 439 } 440 441 void 442 ktefree(struct ktrace_entry *kte) 443 { 444 445 if (kte->kte_buf != kte->kte_space) 446 kmem_free(kte->kte_buf, kte->kte_bufsz); 447 pool_cache_put(kte_cache, kte); 448 } 449 450 /* 451 * "deep" compare of two files for the purposes of clearing a trace. 452 * Returns true if they're the same open file, or if they point at the 453 * same underlying vnode/socket. 454 */ 455 456 int 457 ktrsamefile(file_t *f1, file_t *f2) 458 { 459 460 return ((f1 == f2) || 461 ((f1 != NULL) && (f2 != NULL) && 462 (f1->f_type == f2->f_type) && 463 (f1->f_data == f2->f_data))); 464 } 465 466 void 467 ktrderef(struct proc *p) 468 { 469 struct ktr_desc *ktd = p->p_tracep; 470 471 KASSERT(mutex_owned(&ktrace_lock)); 472 473 p->p_traceflag = 0; 474 if (ktd == NULL) 475 return; 476 p->p_tracep = NULL; 477 478 cv_broadcast(&ktd->ktd_sync_cv); 479 ktdrel(ktd); 480 } 481 482 void 483 ktradref(struct proc *p) 484 { 485 struct ktr_desc *ktd = p->p_tracep; 486 487 KASSERT(mutex_owned(&ktrace_lock)); 488 489 ktdref(ktd); 490 } 491 492 int 493 ktrderefall(struct ktr_desc *ktd, int auth) 494 { 495 lwp_t *curl = curlwp; 496 struct proc *p; 497 int error = 0; 498 499 mutex_enter(proc_lock); 500 PROCLIST_FOREACH(p, &allproc) { 501 if (p->p_tracep != ktd) 502 continue; 503 mutex_enter(p->p_lock); 504 mutex_enter(&ktrace_lock); 505 if (p->p_tracep == ktd) { 506 if (!auth || ktrcanset(curl, p)) 507 ktrderef(p); 508 else 509 error = EPERM; 510 } 511 mutex_exit(&ktrace_lock); 512 mutex_exit(p->p_lock); 513 } 514 mutex_exit(proc_lock); 515 516 return error; 517 } 518 519 int 520 ktealloc(struct ktrace_entry **ktep, void **bufp, lwp_t *l, int type, 521 size_t sz) 522 { 523 struct proc *p = l->l_proc; 524 struct ktrace_entry *kte; 525 struct ktr_header *kth; 526 void *buf; 527 528 if (ktrenter(l)) 529 return EAGAIN; 530 531 kte = pool_cache_get(kte_cache, PR_WAITOK); 532 if (sz > sizeof(kte->kte_space)) { 533 if ((buf = kmem_alloc(sz, KM_SLEEP)) == NULL) { 534 pool_cache_put(kte_cache, kte); 535 ktrexit(l); 536 return ENOMEM; 537 } 538 } else 539 buf = kte->kte_space; 540 541 kte->kte_bufsz = sz; 542 kte->kte_buf = buf; 543 544 kth = &kte->kte_kth; 545 (void)memset(kth, 0, sizeof(*kth)); 546 kth->ktr_len = sz; 547 kth->ktr_type = type; 548 kth->ktr_pid = p->p_pid; 549 memcpy(kth->ktr_comm, p->p_comm, MAXCOMLEN); 550 kth->ktr_version = KTRFAC_VERSION(p->p_traceflag); 551 kth->ktr_lid = l->l_lid; 552 nanotime(&kth->ktr_ts); 553 554 *ktep = kte; 555 *bufp = buf; 556 557 return 0; 558 } 559 560 void 561 ktr_syscall(register_t code, const register_t args[], int narg) 562 { 563 lwp_t *l = curlwp; 564 struct proc *p = l->l_proc; 565 struct ktrace_entry *kte; 566 struct ktr_syscall *ktp; 567 register_t *argp; 568 size_t len; 569 u_int i; 570 571 if (!KTRPOINT(p, KTR_SYSCALL)) 572 return; 573 574 len = sizeof(struct ktr_syscall) + narg * sizeof argp[0]; 575 576 if (ktealloc(&kte, (void *)&ktp, l, KTR_SYSCALL, len)) 577 return; 578 579 ktp->ktr_code = code; 580 ktp->ktr_argsize = narg * sizeof argp[0]; 581 argp = (register_t *)(ktp + 1); 582 for (i = 0; i < narg; i++) 583 *argp++ = args[i]; 584 585 ktraddentry(l, kte, KTA_WAITOK); 586 } 587 588 void 589 ktr_sysret(register_t code, int error, register_t *retval) 590 { 591 lwp_t *l = curlwp; 592 struct ktrace_entry *kte; 593 struct ktr_sysret *ktp; 594 595 if (!KTRPOINT(l->l_proc, KTR_SYSRET)) 596 return; 597 598 if (ktealloc(&kte, (void *)&ktp, l, KTR_SYSRET, 599 sizeof(struct ktr_sysret))) 600 return; 601 602 ktp->ktr_code = code; 603 ktp->ktr_eosys = 0; /* XXX unused */ 604 ktp->ktr_error = error; 605 ktp->ktr_retval = retval && error == 0 ? retval[0] : 0; 606 ktp->ktr_retval_1 = retval && error == 0 ? retval[1] : 0; 607 608 ktraddentry(l, kte, KTA_WAITOK); 609 } 610 611 void 612 ktr_namei(const char *path, size_t pathlen) 613 { 614 lwp_t *l = curlwp; 615 616 if (!KTRPOINT(l->l_proc, KTR_NAMEI)) 617 return; 618 619 ktr_kmem(l, KTR_NAMEI, path, pathlen); 620 } 621 622 void 623 ktr_namei2(const char *eroot, size_t erootlen, 624 const char *path, size_t pathlen) 625 { 626 lwp_t *l = curlwp; 627 struct ktrace_entry *kte; 628 void *buf; 629 630 if (!KTRPOINT(l->l_proc, KTR_NAMEI)) 631 return; 632 633 if (ktealloc(&kte, &buf, l, KTR_NAMEI, erootlen + pathlen)) 634 return; 635 memcpy(buf, eroot, erootlen); 636 buf = (char *)buf + erootlen; 637 memcpy(buf, path, pathlen); 638 ktraddentry(l, kte, KTA_WAITOK); 639 } 640 641 void 642 ktr_emul(void) 643 { 644 lwp_t *l = curlwp; 645 const char *emul = l->l_proc->p_emul->e_name; 646 647 if (!KTRPOINT(l->l_proc, KTR_EMUL)) 648 return; 649 650 ktr_kmem(l, KTR_EMUL, emul, strlen(emul)); 651 } 652 653 void 654 ktr_execarg(const void *bf, size_t len) 655 { 656 lwp_t *l = curlwp; 657 658 if (!KTRPOINT(l->l_proc, KTR_EXEC_ARG)) 659 return; 660 661 ktr_kmem(l, KTR_EXEC_ARG, bf, len); 662 } 663 664 void 665 ktr_execenv(const void *bf, size_t len) 666 { 667 lwp_t *l = curlwp; 668 669 if (!KTRPOINT(l->l_proc, KTR_EXEC_ENV)) 670 return; 671 672 ktr_kmem(l, KTR_EXEC_ENV, bf, len); 673 } 674 675 void 676 ktr_execfd(int fd, u_int dtype) 677 { 678 struct ktrace_entry *kte; 679 struct ktr_execfd* ktp; 680 681 lwp_t *l = curlwp; 682 683 if (!KTRPOINT(l->l_proc, KTR_EXEC_FD)) 684 return; 685 686 if (ktealloc(&kte, (void *)&ktp, l, KTR_EXEC_FD, sizeof(*ktp))) 687 return; 688 689 ktp->ktr_fd = fd; 690 ktp->ktr_dtype = dtype; 691 ktraddentry(l, kte, KTA_WAITOK); 692 } 693 694 static void 695 ktr_kmem(lwp_t *l, int type, const void *bf, size_t len) 696 { 697 struct ktrace_entry *kte; 698 void *buf; 699 700 if (ktealloc(&kte, &buf, l, type, len)) 701 return; 702 memcpy(buf, bf, len); 703 ktraddentry(l, kte, KTA_WAITOK); 704 } 705 706 static void 707 ktr_io(lwp_t *l, int fd, enum uio_rw rw, struct iovec *iov, size_t len) 708 { 709 struct ktrace_entry *kte; 710 struct ktr_genio *ktp; 711 size_t resid = len, cnt, buflen; 712 char *cp; 713 714 next: 715 buflen = min(PAGE_SIZE, resid + sizeof(struct ktr_genio)); 716 717 if (ktealloc(&kte, (void *)&ktp, l, KTR_GENIO, buflen)) 718 return; 719 720 ktp->ktr_fd = fd; 721 ktp->ktr_rw = rw; 722 723 cp = (void *)(ktp + 1); 724 buflen -= sizeof(struct ktr_genio); 725 kte->kte_kth.ktr_len = sizeof(struct ktr_genio); 726 727 while (buflen > 0) { 728 cnt = min(iov->iov_len, buflen); 729 if (copyin(iov->iov_base, cp, cnt) != 0) 730 goto out; 731 kte->kte_kth.ktr_len += cnt; 732 cp += cnt; 733 buflen -= cnt; 734 resid -= cnt; 735 iov->iov_len -= cnt; 736 if (iov->iov_len == 0) 737 iov++; 738 else 739 iov->iov_base = (char *)iov->iov_base + cnt; 740 } 741 742 /* 743 * Don't push so many entry at once. It will cause kmem map 744 * shortage. 745 */ 746 ktraddentry(l, kte, KTA_WAITOK | KTA_LARGE); 747 if (resid > 0) { 748 if (curcpu()->ci_schedstate.spc_flags & SPCF_SHOULDYIELD) { 749 (void)ktrenter(l); 750 preempt(); 751 ktrexit(l); 752 } 753 754 goto next; 755 } 756 757 return; 758 759 out: 760 ktefree(kte); 761 ktrexit(l); 762 } 763 764 void 765 ktr_genio(int fd, enum uio_rw rw, const void *addr, size_t len, int error) 766 { 767 lwp_t *l = curlwp; 768 struct iovec iov; 769 770 if (!KTRPOINT(l->l_proc, KTR_GENIO) || error != 0) 771 return; 772 iov.iov_base = __UNCONST(addr); 773 iov.iov_len = len; 774 ktr_io(l, fd, rw, &iov, len); 775 } 776 777 void 778 ktr_geniov(int fd, enum uio_rw rw, struct iovec *iov, size_t len, int error) 779 { 780 lwp_t *l = curlwp; 781 782 if (!KTRPOINT(l->l_proc, KTR_GENIO) || error != 0) 783 return; 784 ktr_io(l, fd, rw, iov, len); 785 } 786 787 void 788 ktr_mibio(int fd, enum uio_rw rw, const void *addr, size_t len, int error) 789 { 790 lwp_t *l = curlwp; 791 struct iovec iov; 792 793 if (!KTRPOINT(l->l_proc, KTR_MIB) || error != 0) 794 return; 795 iov.iov_base = __UNCONST(addr); 796 iov.iov_len = len; 797 ktr_io(l, fd, rw, &iov, len); 798 } 799 800 void 801 ktr_psig(int sig, sig_t action, const sigset_t *mask, 802 const ksiginfo_t *ksi) 803 { 804 struct ktrace_entry *kte; 805 lwp_t *l = curlwp; 806 struct { 807 struct ktr_psig kp; 808 siginfo_t si; 809 } *kbuf; 810 811 if (!KTRPOINT(l->l_proc, KTR_PSIG)) 812 return; 813 814 if (ktealloc(&kte, (void *)&kbuf, l, KTR_PSIG, sizeof(*kbuf))) 815 return; 816 817 kbuf->kp.signo = (char)sig; 818 kbuf->kp.action = action; 819 kbuf->kp.mask = *mask; 820 821 if (ksi) { 822 kbuf->kp.code = KSI_TRAPCODE(ksi); 823 (void)memset(&kbuf->si, 0, sizeof(kbuf->si)); 824 kbuf->si._info = ksi->ksi_info; 825 kte->kte_kth.ktr_len = sizeof(*kbuf); 826 } else { 827 kbuf->kp.code = 0; 828 kte->kte_kth.ktr_len = sizeof(struct ktr_psig); 829 } 830 831 ktraddentry(l, kte, KTA_WAITOK); 832 } 833 834 void 835 ktr_csw(int out, int user) 836 { 837 lwp_t *l = curlwp; 838 struct proc *p = l->l_proc; 839 struct ktrace_entry *kte; 840 struct ktr_csw *kc; 841 842 if (!KTRPOINT(p, KTR_CSW)) 843 return; 844 845 /* 846 * Don't record context switches resulting from blocking on 847 * locks; it's too easy to get duff results. 848 */ 849 if (l->l_syncobj == &mutex_syncobj || l->l_syncobj == &rw_syncobj) 850 return; 851 852 /* 853 * We can't sleep if we're already going to sleep (if original 854 * condition is met during sleep, we hang up). 855 * 856 * XXX This is not ideal: it would be better to maintain a pool 857 * of ktes and actually push this to the kthread when context 858 * switch happens, however given the points where we are called 859 * from that is difficult to do. 860 */ 861 if (out) { 862 if (ktrenter(l)) 863 return; 864 865 nanotime(&l->l_ktrcsw); 866 l->l_pflag |= LP_KTRCSW; 867 if (user) 868 l->l_pflag |= LP_KTRCSWUSER; 869 else 870 l->l_pflag &= ~LP_KTRCSWUSER; 871 872 ktrexit(l); 873 return; 874 } 875 876 /* 877 * On the way back in, we need to record twice: once for entry, and 878 * once for exit. 879 */ 880 if ((l->l_pflag & LP_KTRCSW) != 0) { 881 struct timespec *ts; 882 l->l_pflag &= ~LP_KTRCSW; 883 884 if (ktealloc(&kte, (void *)&kc, l, KTR_CSW, sizeof(*kc))) 885 return; 886 887 kc->out = 1; 888 kc->user = ((l->l_pflag & LP_KTRCSWUSER) != 0); 889 890 ts = &l->l_ktrcsw; 891 switch (KTRFAC_VERSION(p->p_traceflag)) { 892 case 0: 893 kte->kte_kth.ktr_otv.tv_sec = ts->tv_sec; 894 kte->kte_kth.ktr_otv.tv_usec = ts->tv_nsec / 1000; 895 break; 896 case 1: 897 kte->kte_kth.ktr_ots.tv_sec = ts->tv_sec; 898 kte->kte_kth.ktr_ots.tv_nsec = ts->tv_nsec; 899 break; 900 case 2: 901 kte->kte_kth.ktr_ts.tv_sec = ts->tv_sec; 902 kte->kte_kth.ktr_ts.tv_nsec = ts->tv_nsec; 903 break; 904 default: 905 break; 906 } 907 908 ktraddentry(l, kte, KTA_WAITOK); 909 } 910 911 if (ktealloc(&kte, (void *)&kc, l, KTR_CSW, sizeof(*kc))) 912 return; 913 914 kc->out = 0; 915 kc->user = user; 916 917 ktraddentry(l, kte, KTA_WAITOK); 918 } 919 920 bool 921 ktr_point(int fac_bit) 922 { 923 return curlwp->l_proc->p_traceflag & fac_bit; 924 } 925 926 int 927 ktruser(const char *id, void *addr, size_t len, int ustr) 928 { 929 struct ktrace_entry *kte; 930 struct ktr_user *ktp; 931 lwp_t *l = curlwp; 932 void *user_dta; 933 int error; 934 935 if (!KTRPOINT(l->l_proc, KTR_USER)) 936 return 0; 937 938 if (len > KTR_USER_MAXLEN) 939 return ENOSPC; 940 941 error = ktealloc(&kte, (void *)&ktp, l, KTR_USER, sizeof(*ktp) + len); 942 if (error != 0) 943 return error; 944 945 if (ustr) { 946 if (copyinstr(id, ktp->ktr_id, KTR_USER_MAXIDLEN, NULL) != 0) 947 ktp->ktr_id[0] = '\0'; 948 } else 949 strncpy(ktp->ktr_id, id, KTR_USER_MAXIDLEN); 950 ktp->ktr_id[KTR_USER_MAXIDLEN-1] = '\0'; 951 952 user_dta = (void *)(ktp + 1); 953 if ((error = copyin(addr, (void *)user_dta, len)) != 0) 954 len = 0; 955 956 ktraddentry(l, kte, KTA_WAITOK); 957 return error; 958 } 959 960 void 961 ktr_kuser(const char *id, void *addr, size_t len) 962 { 963 struct ktrace_entry *kte; 964 struct ktr_user *ktp; 965 lwp_t *l = curlwp; 966 int error; 967 968 if (!KTRPOINT(l->l_proc, KTR_USER)) 969 return; 970 971 if (len > KTR_USER_MAXLEN) 972 return; 973 974 error = ktealloc(&kte, (void *)&ktp, l, KTR_USER, sizeof(*ktp) + len); 975 if (error != 0) 976 return; 977 978 strlcpy(ktp->ktr_id, id, KTR_USER_MAXIDLEN); 979 980 memcpy(ktp + 1, addr, len); 981 982 ktraddentry(l, kte, KTA_WAITOK); 983 } 984 985 void 986 ktr_mib(const int *name, u_int namelen) 987 { 988 struct ktrace_entry *kte; 989 int *namep; 990 size_t size; 991 lwp_t *l = curlwp; 992 993 if (!KTRPOINT(l->l_proc, KTR_MIB)) 994 return; 995 996 size = namelen * sizeof(*name); 997 998 if (ktealloc(&kte, (void *)&namep, l, KTR_MIB, size)) 999 return; 1000 1001 (void)memcpy(namep, name, namelen * sizeof(*name)); 1002 1003 ktraddentry(l, kte, KTA_WAITOK); 1004 } 1005 1006 /* Interface and common routines */ 1007 1008 int 1009 ktrace_common(lwp_t *curl, int ops, int facs, int pid, file_t **fpp) 1010 { 1011 struct proc *curp; 1012 struct proc *p; 1013 struct pgrp *pg; 1014 struct ktr_desc *ktd = NULL; 1015 file_t *fp = *fpp; 1016 int ret = 0; 1017 int error = 0; 1018 int descend; 1019 1020 curp = curl->l_proc; 1021 descend = ops & KTRFLAG_DESCEND; 1022 facs = facs & ~((unsigned) KTRFAC_PERSISTENT); 1023 1024 (void)ktrenter(curl); 1025 1026 switch (KTROP(ops)) { 1027 1028 case KTROP_CLEARFILE: 1029 /* 1030 * Clear all uses of the tracefile 1031 */ 1032 mutex_enter(&ktrace_lock); 1033 ktd = ktd_lookup(fp); 1034 mutex_exit(&ktrace_lock); 1035 if (ktd == NULL) 1036 goto done; 1037 error = ktrderefall(ktd, 1); 1038 goto done; 1039 1040 case KTROP_SET: 1041 mutex_enter(&ktrace_lock); 1042 ktd = ktd_lookup(fp); 1043 mutex_exit(&ktrace_lock); 1044 if (ktd == NULL) { 1045 ktd = kmem_alloc(sizeof(*ktd), KM_SLEEP); 1046 TAILQ_INIT(&ktd->ktd_queue); 1047 callout_init(&ktd->ktd_wakch, CALLOUT_MPSAFE); 1048 cv_init(&ktd->ktd_cv, "ktrwait"); 1049 cv_init(&ktd->ktd_sync_cv, "ktrsync"); 1050 ktd->ktd_flags = 0; 1051 ktd->ktd_qcount = 0; 1052 ktd->ktd_error = 0; 1053 ktd->ktd_errcnt = 0; 1054 ktd->ktd_delayqcnt = ktd_delayqcnt; 1055 ktd->ktd_wakedelay = mstohz(ktd_wakedelay); 1056 ktd->ktd_intrwakdl = mstohz(ktd_intrwakdl); 1057 ktd->ktd_ref = 0; 1058 ktd->ktd_fp = fp; 1059 mutex_enter(&ktrace_lock); 1060 ktdref(ktd); 1061 mutex_exit(&ktrace_lock); 1062 1063 /* 1064 * XXX: not correct. needs an way to detect 1065 * whether ktruss or ktrace. 1066 */ 1067 if (fp->f_type == DTYPE_PIPE) 1068 ktd->ktd_flags |= KTDF_INTERACTIVE; 1069 1070 mutex_enter(&fp->f_lock); 1071 fp->f_count++; 1072 mutex_exit(&fp->f_lock); 1073 error = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL, 1074 ktrace_thread, ktd, &ktd->ktd_lwp, "ktrace"); 1075 if (error != 0) { 1076 kmem_free(ktd, sizeof(*ktd)); 1077 ktd = NULL; 1078 mutex_enter(&fp->f_lock); 1079 fp->f_count--; 1080 mutex_exit(&fp->f_lock); 1081 goto done; 1082 } 1083 1084 mutex_enter(&ktrace_lock); 1085 if (ktd_lookup(fp) != NULL) { 1086 ktdrel(ktd); 1087 ktd = NULL; 1088 } else 1089 TAILQ_INSERT_TAIL(&ktdq, ktd, ktd_list); 1090 if (ktd == NULL) 1091 cv_wait(&lbolt, &ktrace_lock); 1092 mutex_exit(&ktrace_lock); 1093 if (ktd == NULL) 1094 goto done; 1095 } 1096 break; 1097 1098 case KTROP_CLEAR: 1099 break; 1100 } 1101 1102 /* 1103 * need something to (un)trace (XXX - why is this here?) 1104 */ 1105 if (!facs) { 1106 error = EINVAL; 1107 *fpp = NULL; 1108 goto done; 1109 } 1110 1111 /* 1112 * do it 1113 */ 1114 mutex_enter(proc_lock); 1115 if (pid < 0) { 1116 /* 1117 * by process group 1118 */ 1119 pg = pgrp_find(-pid); 1120 if (pg == NULL) 1121 error = ESRCH; 1122 else { 1123 LIST_FOREACH(p, &pg->pg_members, p_pglist) { 1124 if (descend) 1125 ret |= ktrsetchildren(curl, p, ops, 1126 facs, ktd); 1127 else 1128 ret |= ktrops(curl, p, ops, facs, 1129 ktd); 1130 } 1131 } 1132 1133 } else { 1134 /* 1135 * by pid 1136 */ 1137 p = proc_find(pid); 1138 if (p == NULL) 1139 error = ESRCH; 1140 else if (descend) 1141 ret |= ktrsetchildren(curl, p, ops, facs, ktd); 1142 else 1143 ret |= ktrops(curl, p, ops, facs, ktd); 1144 } 1145 mutex_exit(proc_lock); 1146 if (error == 0 && !ret) 1147 error = EPERM; 1148 *fpp = NULL; 1149 done: 1150 if (ktd != NULL) { 1151 mutex_enter(&ktrace_lock); 1152 if (error != 0) { 1153 /* 1154 * Wakeup the thread so that it can be die if we 1155 * can't trace any process. 1156 */ 1157 ktd_wakeup(ktd); 1158 } 1159 if (KTROP(ops) == KTROP_SET || KTROP(ops) == KTROP_CLEARFILE) 1160 ktdrel(ktd); 1161 mutex_exit(&ktrace_lock); 1162 } 1163 ktrexit(curl); 1164 return (error); 1165 } 1166 1167 /* 1168 * fktrace system call 1169 */ 1170 /* ARGSUSED */ 1171 int 1172 sys_fktrace(struct lwp *l, const struct sys_fktrace_args *uap, register_t *retval) 1173 { 1174 /* { 1175 syscallarg(int) fd; 1176 syscallarg(int) ops; 1177 syscallarg(int) facs; 1178 syscallarg(int) pid; 1179 } */ 1180 file_t *fp; 1181 int error, fd; 1182 1183 fd = SCARG(uap, fd); 1184 if ((fp = fd_getfile(fd)) == NULL) 1185 return (EBADF); 1186 if ((fp->f_flag & FWRITE) == 0) 1187 error = EBADF; 1188 else 1189 error = ktrace_common(l, SCARG(uap, ops), 1190 SCARG(uap, facs), SCARG(uap, pid), &fp); 1191 fd_putfile(fd); 1192 return error; 1193 } 1194 1195 /* 1196 * ktrace system call 1197 */ 1198 /* ARGSUSED */ 1199 int 1200 sys_ktrace(struct lwp *l, const struct sys_ktrace_args *uap, register_t *retval) 1201 { 1202 /* { 1203 syscallarg(const char *) fname; 1204 syscallarg(int) ops; 1205 syscallarg(int) facs; 1206 syscallarg(int) pid; 1207 } */ 1208 struct vnode *vp = NULL; 1209 file_t *fp = NULL; 1210 struct pathbuf *pb; 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 error = pathbuf_copyin(SCARG(uap, fname), &pb); 1223 if (error) { 1224 ktrexit(l); 1225 return (error); 1226 } 1227 NDINIT(&nd, LOOKUP, FOLLOW, pb); 1228 if ((error = vn_open(&nd, FREAD|FWRITE, 0)) != 0) { 1229 pathbuf_destroy(pb); 1230 ktrexit(l); 1231 return (error); 1232 } 1233 vp = nd.ni_vp; 1234 pathbuf_destroy(pb); 1235 VOP_UNLOCK(vp); 1236 if (vp->v_type != VREG) { 1237 vn_close(vp, FREAD|FWRITE, l->l_cred); 1238 ktrexit(l); 1239 return (EACCES); 1240 } 1241 /* 1242 * This uses up a file descriptor slot in the 1243 * tracing process for the duration of this syscall. 1244 * This is not expected to be a problem. 1245 */ 1246 if ((error = fd_allocfile(&fp, &fd)) != 0) { 1247 vn_close(vp, FWRITE, l->l_cred); 1248 ktrexit(l); 1249 return error; 1250 } 1251 fp->f_flag = FWRITE; 1252 fp->f_type = DTYPE_VNODE; 1253 fp->f_ops = &vnops; 1254 fp->f_data = (void *)vp; 1255 vp = NULL; 1256 } 1257 error = ktrace_common(l, SCARG(uap, ops), SCARG(uap, facs), 1258 SCARG(uap, pid), &fp); 1259 if (KTROP(SCARG(uap, ops)) != KTROP_CLEAR) 1260 fd_abort(curproc, fp, fd); 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_lock); 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_lock); 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(proc_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 cv_destroy(&ktd->ktd_sync_cv); 1507 cv_destroy(&ktd->ktd_cv); 1508 1509 callout_stop(&ktd->ktd_wakch); 1510 callout_destroy(&ktd->ktd_wakch); 1511 kmem_free(ktd, sizeof(*ktd)); 1512 1513 kthread_exit(0); 1514 } 1515 1516 /* 1517 * Return true if caller has permission to set the ktracing state 1518 * of target. Essentially, the target can't possess any 1519 * more permissions than the caller. KTRFAC_PERSISTENT signifies that 1520 * the tracing will persist on sugid processes during exec; it is only 1521 * settable by a process with appropriate credentials. 1522 * 1523 * TODO: check groups. use caller effective gid. 1524 */ 1525 int 1526 ktrcanset(lwp_t *calll, struct proc *targetp) 1527 { 1528 KASSERT(mutex_owned(targetp->p_lock)); 1529 KASSERT(mutex_owned(&ktrace_lock)); 1530 1531 if (kauth_authorize_process(calll->l_cred, KAUTH_PROCESS_KTRACE, 1532 targetp, NULL, NULL, NULL) == 0) 1533 return (1); 1534 1535 return (0); 1536 } 1537 1538 /* 1539 * Put user defined entry to ktrace records. 1540 */ 1541 int 1542 sys_utrace(struct lwp *l, const struct sys_utrace_args *uap, register_t *retval) 1543 { 1544 /* { 1545 syscallarg(const char *) label; 1546 syscallarg(void *) addr; 1547 syscallarg(size_t) len; 1548 } */ 1549 1550 return ktruser(SCARG(uap, label), SCARG(uap, addr), 1551 SCARG(uap, len), 1); 1552 } 1553