1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 27 /* 28 * tnf driver - provides probe control and kernel trace buffer access 29 * to the user programs prex and tnfxtract. 30 */ 31 32 #include <sys/types.h> 33 #include <sys/param.h> 34 #include <sys/sysmacros.h> 35 #include <sys/file.h> 36 #include <sys/cmn_err.h> 37 #include <sys/fcntl.h> 38 #include <sys/uio.h> 39 #include <sys/kmem.h> 40 #include <sys/cred.h> 41 #include <sys/mman.h> 42 #include <sys/errno.h> 43 #include <sys/stat.h> 44 #include <sys/conf.h> 45 #include <sys/ddi.h> 46 #include <sys/sunddi.h> 47 #include <sys/modctl.h> 48 #include <sys/tnf.h> 49 #include <sys/debug.h> 50 #include <sys/devops.h> 51 #include <vm/as.h> 52 #include <vm/seg_kp.h> 53 #include <sys/tnf_probe.h> 54 #include <sys/kobj.h> 55 56 #include "tnf_buf.h" 57 #include "tnf_types.h" 58 #include "tnf_trace.h" 59 60 #ifndef NPROBE 61 62 /* 63 * Each probe is independently put in the kernel, prex uses 64 * __tnf_probe_list_head and __tnf_tag_list_head as pointers to linked list 65 * for probes and static tnf_tag_data_t, respectively. 66 * tnf used the elf relocation record to build a separate linked list for 67 * the probes and tnf_tag_data_t. We will describe how the linked list for 68 * __tnf_tag_list_head is made, the probe list is very similar. 69 * During the dynamic relocation(in uts/sparc/krtld/kobj_reloc.c), 70 * the &__tnf_tag_version_1(the first member in tnf_tag_data_t data struct) 71 * (and since it is a global variable which was never defined) will be filled 72 * with 0. The following code in kobj_reloc.c will get the address of current 73 * __tnf_tag_list_head and put it in value_p: 74 * #define TAG_MARKER_SYMBOL "__tnf_tag_version_1" 75 * if (strcmp(symname, TAG_MARKER_SYMBOL) == 0) { 76 * *addend_p = 0; 77 * *value_p = (Addr) __tnf_tag_list_head; (value_p points to list head) 78 * __tnf_tag_list_head = (void *)*offset_p;(list head is the next record) 79 * return (0); 80 * } 81 * 82 * the function do_reloc(in the kobj_reloc.c) will put vlaue_p into 83 * &__tnf_tag_version_1 84 * Now the &__tnf_tag_version_1 points to the last list head 85 * and __tnf_tag_list_head points to the new list head. 86 * This is equivalent to attatch a node at the beginning of the list. 87 * 88 */ 89 extern tnf_probe_control_t *__tnf_probe_list_head; 90 extern tnf_tag_data_t *__tnf_tag_list_head; 91 extern int tnf_changed_probe_list; 92 93 static int tnf_attach(dev_info_t *, ddi_attach_cmd_t); 94 static int tnf_detach(dev_info_t *, ddi_detach_cmd_t); 95 static int tnf_info(dev_info_t *, ddi_info_cmd_t, void *, void **); 96 static int tnf_open(dev_t *, int, int, struct cred *); 97 static int tnf_close(dev_t, int, int, struct cred *); 98 #ifdef UNUSED 99 static int tnf_mmap(dev_t, off_t, int); 100 #endif 101 static int tnf_ioctl(dev_t, int, intptr_t, int, struct cred *, int *); 102 #ifdef UNUSED 103 static int tnf_prop_op(dev_t, dev_info_t *, ddi_prop_op_t, 104 int, char *, caddr_t, int *); 105 #endif 106 static dev_info_t *tnf_devi; 107 108 static struct { 109 int tnf_probe_count; 110 boolean_t tnf_pidfilter_mode; 111 boolean_t ctldev_is_open; 112 int mapdev_open_count; 113 kmutex_t tnf_mtx; 114 } tnf_drv_state = { 0, B_FALSE, B_FALSE, 0 }; 115 116 static int tnf_getmaxprobe(caddr_t, int); 117 static int tnf_getprobevals(caddr_t, int); 118 static int tnf_getprobestring(caddr_t, int); 119 static int tnf_setprobevals(caddr_t, int); 120 static int tnf_getstate(caddr_t, int); 121 static int tnf_allocbuf(intptr_t); 122 static int tnf_deallocbuf(void); 123 static int tnf_settracing(int); 124 static int tnf_pidfilterset(int); 125 static int tnf_pidfilterget(caddr_t, int); 126 static int tnf_getpidstate(caddr_t, int); 127 static int tnf_setpidstate(int, pid_t, int); 128 static int tnf_getheader(caddr_t, int); 129 static int tnf_getblock(caddr_t, int); 130 static int tnf_getfwzone(caddr_t, int); 131 132 static void *tnf_test_1(void *, tnf_probe_control_t *, tnf_probe_setup_t *); 133 static void *tnf_test_2(void *, tnf_probe_control_t *, tnf_probe_setup_t *); 134 135 #define TNFCTL_MINOR 0 136 #define TNFMAP_MINOR 1 137 138 struct cb_ops tnf_cb_ops = { 139 tnf_open, /* open */ 140 tnf_close, /* close */ 141 nodev, /* strategy */ 142 nodev, /* print */ 143 nodev, /* dump */ 144 nodev, /* read */ 145 nodev, /* write */ 146 tnf_ioctl, /* ioctl */ 147 nodev, /* devmap */ 148 nodev, /* mmap */ 149 nodev, /* segmap */ 150 nochpoll, /* poll */ 151 ddi_prop_op, /* prop_op */ 152 0, /* streamtab */ 153 D_NEW | D_MP /* Driver compatibility flag */ 154 }; 155 156 struct dev_ops tnf_ops = { 157 DEVO_REV, /* devo_rev, */ 158 0, /* refcnt */ 159 tnf_info, /* info */ 160 nulldev, /* identify */ 161 nulldev, /* probe */ 162 tnf_attach, /* attach */ 163 tnf_detach, /* detach */ 164 nodev, /* reset */ 165 &tnf_cb_ops, /* driver operations */ 166 (struct bus_ops *)0, /* no bus operations */ 167 NULL, /* power */ 168 ddi_quiesce_not_needed, /* quiesce */ 169 }; 170 171 extern struct mod_ops mod_driverops; 172 173 static struct modldrv modldrv = { 174 &mod_driverops, 175 "kernel probes driver", 176 &tnf_ops, 177 }; 178 179 static struct modlinkage modlinkage = { 180 MODREV_1, 181 (void *)&modldrv, 182 NULL 183 }; 184 185 int 186 _init() 187 { 188 register int error; 189 190 mutex_init(&tnf_drv_state.tnf_mtx, NULL, MUTEX_DEFAULT, NULL); 191 192 if ((error = mod_install(&modlinkage)) != 0) { 193 mutex_destroy(&tnf_drv_state.tnf_mtx); 194 return (error); 195 } 196 197 /* Give t0 a tpdp */ 198 if (!t0.t_tnf_tpdp) 199 t0.t_tnf_tpdp = kmem_zalloc(sizeof (tnf_ops_t), KM_SLEEP); 200 /* Initialize tag system */ 201 tnf_tag_core_init(); 202 tnf_tag_trace_init(); 203 tnf_changed_probe_list = 1; 204 return (0); 205 } 206 207 int 208 _fini() 209 { 210 /* Not safe to unload this module, currently */ 211 return (EBUSY); 212 } 213 214 int 215 _info(struct modinfo *modinfop) 216 { 217 return (mod_info(&modlinkage, modinfop)); 218 } 219 220 /* ARGSUSED */ 221 static int 222 tnf_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 223 { 224 register int error; 225 226 switch (infocmd) { 227 case DDI_INFO_DEVT2DEVINFO: 228 *result = (void *)tnf_devi; 229 error = DDI_SUCCESS; 230 break; 231 case DDI_INFO_DEVT2INSTANCE: 232 *result = (void *)0; 233 error = DDI_SUCCESS; 234 break; 235 default: 236 error = DDI_FAILURE; 237 } 238 return (error); 239 } 240 241 static int 242 tnf_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) 243 { 244 if (cmd != DDI_ATTACH) 245 return (DDI_FAILURE); 246 if ((ddi_create_minor_node(devi, "tnfctl", S_IFCHR, TNFCTL_MINOR, 247 DDI_PSEUDO, NULL) == DDI_FAILURE) || 248 (ddi_create_minor_node(devi, "tnfmap", S_IFCHR, TNFMAP_MINOR, 249 DDI_PSEUDO, NULL) == DDI_FAILURE)) { 250 ddi_remove_minor_node(devi, NULL); 251 return (DDI_FAILURE); 252 } 253 tnf_devi = devi; 254 return (DDI_SUCCESS); 255 } 256 257 static int 258 tnf_detach(dev_info_t *devi, ddi_detach_cmd_t cmd) 259 { 260 if (cmd != DDI_DETACH) 261 return (DDI_FAILURE); 262 ddi_remove_minor_node(devi, NULL); 263 return (DDI_SUCCESS); 264 } 265 266 /* 267 * property operations. Return the size of the kernel trace buffer. We 268 * only handle size property requests. Others are passed on. 269 */ 270 #ifdef UNUSED 271 static int 272 tnf_prop_op(dev_t dev, dev_info_t *di, ddi_prop_op_t prop, 273 int m, char *name, caddr_t valuep, int *lengthp) 274 { 275 int length, *retbuf, size; 276 277 if (strcmp(name, "size") == 0) { 278 279 /* Don't need tnf_mtx, since mapdev_open_count > 0 */ 280 size = tnf_trace_file_size; 281 282 length = *lengthp; /* get caller's length */ 283 *lengthp = sizeof (int); /* set caller's length */ 284 285 switch (prop) { 286 287 case PROP_LEN: 288 return (DDI_PROP_SUCCESS); 289 290 case PROP_LEN_AND_VAL_ALLOC: 291 retbuf = kmem_alloc(sizeof (int), 292 (m & DDI_PROP_CANSLEEP) ? KM_SLEEP : KM_NOSLEEP); 293 if (retbuf == NULL) 294 return (DDI_PROP_NO_MEMORY); 295 *(int **)valuep = retbuf; /* set caller's buf */ 296 *retbuf = size; 297 return (DDI_PROP_SUCCESS); 298 299 case PROP_LEN_AND_VAL_BUF: 300 if (length < sizeof (int)) 301 return (DDI_PROP_BUF_TOO_SMALL); 302 *(int *)valuep = size; 303 return (DDI_PROP_SUCCESS); 304 } 305 } 306 return (ddi_prop_op(dev, dip, prop, m, name, valuep, lengthp)); 307 } 308 #endif 309 310 /* ARGSUSED */ 311 static int 312 tnf_open(dev_t *devp, int flag, int otyp, struct cred *cred) 313 { 314 int err = 0; 315 mutex_enter(&tnf_drv_state.tnf_mtx); 316 if (getminor(*devp) == TNFCTL_MINOR) { 317 if (tnf_drv_state.ctldev_is_open) 318 err = EBUSY; 319 else { 320 tnf_drv_state.ctldev_is_open = B_TRUE; 321 /* stop autounloading -- XXX temporary */ 322 modunload_disable(); 323 } 324 } else { 325 /* ASSERT(getminor(*devp) == TNFMAP_MINOR) */ 326 ++tnf_drv_state.mapdev_open_count; 327 } 328 mutex_exit(&tnf_drv_state.tnf_mtx); 329 return (err); 330 } 331 332 /* ARGSUSED */ 333 static int 334 tnf_close(dev_t dev, int flag, int otyp, struct cred *cred) 335 { 336 if (getminor(dev) == TNFCTL_MINOR) { 337 /* 338 * Request the reenablement of autounloading 339 */ 340 modunload_enable(); 341 tnf_drv_state.ctldev_is_open = B_FALSE; 342 } else { 343 /* ASSERT(getminor(dev) == TNFMAP_MINOR) */ 344 /* 345 * Unconditionally zero the open count since close() 346 * is called when last client closes the device. 347 */ 348 tnf_drv_state.mapdev_open_count = 0; 349 } 350 return (0); 351 } 352 353 /* 354 * return the address of the image referenced by dev. 355 * 356 * 1191344: aliasing problem on VAC machines. It could be made to 357 * work by ensuring that tnf_buf is allocated on a vac_size boundary. 358 */ 359 #ifdef UNUSED 360 /*ARGSUSED*/ 361 static int 362 tnf_mmap(dev_t dev, off_t off, int prot) 363 { 364 register caddr_t addr; 365 register caddr_t pg_offset; 366 367 if (getminor(dev) != TNFMAP_MINOR) 368 return (-1); 369 if (tnf_buf == 0 || off >= tnf_trace_file_size) { 370 return (-1); 371 } 372 373 addr = tnf_buf; 374 pg_offset = (caddr_t)((ulong_t)addr + (ulong_t)off); 375 return ((int)hat_getpfnum(kas.a_hat, pg_offset)); 376 } 377 #endif 378 379 /*ARGSUSED4*/ 380 static int 381 tnf_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, 382 cred_t *credp, int *rvalp) 383 { 384 int filterval = 1; 385 386 if ((mode & FMODELS) != FNATIVE) 387 return (ENOTSUP); 388 389 if (getminor(dev) != TNFCTL_MINOR && 390 cmd != TIFIOCGSTATE && 391 cmd != TIFIOCGHEADER && 392 cmd != TIFIOCGBLOCK && 393 cmd != TIFIOCGFWZONE) 394 return (EINVAL); 395 396 switch (cmd) { 397 case TIFIOCGMAXPROBE: 398 return (tnf_getmaxprobe((caddr_t)arg, mode)); 399 case TIFIOCGPROBEVALS: 400 return (tnf_getprobevals((caddr_t)arg, mode)); 401 case TIFIOCGPROBESTRING: 402 return (tnf_getprobestring((caddr_t)arg, mode)); 403 case TIFIOCSPROBEVALS: 404 return (tnf_setprobevals((caddr_t)arg, mode)); 405 case TIFIOCGSTATE: 406 return (tnf_getstate((caddr_t)arg, mode)); 407 case TIFIOCALLOCBUF: 408 return (tnf_allocbuf(arg)); 409 case TIFIOCDEALLOCBUF: 410 return (tnf_deallocbuf()); 411 case TIFIOCSTRACING: 412 /* LINTED cast from 64-bit integer to 32-bit integer */ 413 return (tnf_settracing((int)arg)); 414 case TIFIOCSPIDFILTER: 415 /* LINTED cast from 64-bit integer to 32-bit integer */ 416 return (tnf_pidfilterset((int)arg)); 417 case TIFIOCGPIDSTATE: 418 return (tnf_getpidstate((caddr_t)arg, mode)); 419 case TIFIOCSPIDOFF: 420 filterval = 0; 421 /*FALLTHROUGH*/ 422 case TIFIOCSPIDON: 423 /* LINTED cast from 64-bit integer to 32-bit integer */ 424 return (tnf_setpidstate(filterval, (pid_t)arg, mode)); 425 case TIFIOCPIDFILTERGET: 426 return (tnf_pidfilterget((caddr_t)arg, mode)); 427 case TIFIOCGHEADER: 428 return (tnf_getheader((caddr_t)arg, mode)); 429 case TIFIOCGBLOCK: 430 return (tnf_getblock((caddr_t)arg, mode)); 431 case TIFIOCGFWZONE: 432 return (tnf_getfwzone((caddr_t)arg, mode)); 433 default: 434 return (EINVAL); 435 } 436 } 437 438 /* 439 * ioctls 440 */ 441 442 static int 443 tnf_getmaxprobe(caddr_t arg, int mode) 444 { 445 tnf_probe_control_t *p; 446 /* 447 * XXX Still not right for module unload -- just counting 448 * the probes is not enough 449 */ 450 if (tnf_changed_probe_list) { 451 mutex_enter(&mod_lock); 452 tnf_changed_probe_list = 0; 453 tnf_drv_state.tnf_probe_count = 0; 454 for (p = (tnf_probe_control_t *)__tnf_probe_list_head; 455 p != 0; p = p->next) 456 ++tnf_drv_state.tnf_probe_count; 457 mutex_exit(&mod_lock); 458 } 459 if (ddi_copyout((caddr_t)&tnf_drv_state.tnf_probe_count, 460 arg, sizeof (tnf_drv_state.tnf_probe_count), mode)) 461 return (EFAULT); 462 return (0); 463 } 464 465 static int 466 tnf_getprobevals(caddr_t arg, int mode) 467 { 468 tnf_probevals_t probebuf; 469 tnf_probe_control_t *p; 470 int i, retval = 0; 471 472 if (ddi_copyin(arg, (caddr_t)&probebuf, sizeof (probebuf), mode)) 473 return (EFAULT); 474 475 mutex_enter(&mod_lock); 476 for (i = 1, p = (tnf_probe_control_t *)__tnf_probe_list_head; 477 p != NULL && i != probebuf.probenum; 478 ++i, p = p->next) 479 ; 480 if (p == NULL) 481 retval = ENOENT; 482 else { 483 probebuf.enabled = (p->test_func != NULL); 484 probebuf.traced = (p->probe_func == tnf_trace_commit); 485 /* LINTED assignment of 64-bit integer to 32-bit integer */ 486 probebuf.attrsize = strlen(p->attrs) + 1; 487 if (ddi_copyout((caddr_t)&probebuf, 488 arg, sizeof (probebuf), mode)) 489 retval = EFAULT; 490 } 491 mutex_exit(&mod_lock); 492 return (retval); 493 } 494 495 static int 496 tnf_getprobestring(caddr_t arg, int mode) 497 { 498 tnf_probevals_t probebuf; 499 tnf_probe_control_t *p; 500 int i, retval = 0; 501 502 if (ddi_copyin(arg, (caddr_t)&probebuf, sizeof (probebuf), mode)) 503 return (EFAULT); 504 505 mutex_enter(&mod_lock); 506 for (i = 1, p = (tnf_probe_control_t *)__tnf_probe_list_head; 507 p != NULL && i != probebuf.probenum; 508 ++i, p = p->next) 509 ; 510 if (p == NULL) 511 retval = ENOENT; 512 else if (ddi_copyout((caddr_t)p->attrs, 513 arg, strlen(p->attrs) + 1, mode)) 514 retval = EFAULT; 515 mutex_exit(&mod_lock); 516 return (retval); 517 } 518 519 static int 520 tnf_setprobevals(caddr_t arg, int mode) 521 { 522 tnf_probevals_t probebuf; 523 tnf_probe_control_t *p; 524 int i, retval = 0; 525 526 if (ddi_copyin(arg, (caddr_t)&probebuf, sizeof (probebuf), mode)) 527 return (EFAULT); 528 529 mutex_enter(&mod_lock); 530 for (i = 1, p = (tnf_probe_control_t *)__tnf_probe_list_head; 531 p != NULL && i != probebuf.probenum; 532 ++i, p = p->next) 533 ; 534 if (p == NULL) 535 retval = ENOENT; 536 else { 537 /* 538 * First do trace, then enable. 539 * Set test_func last. 540 */ 541 if (probebuf.traced) 542 p->probe_func = tnf_trace_commit; 543 else 544 p->probe_func = tnf_trace_rollback; 545 if (probebuf.enabled) { 546 p->alloc_func = tnf_trace_alloc; 547 /* this must be set last */ 548 if (tnf_drv_state.tnf_pidfilter_mode) 549 p->test_func = tnf_test_2; 550 else 551 p->test_func = tnf_test_1; 552 } else 553 p->test_func = NULL; 554 } 555 mutex_exit(&mod_lock); 556 return (retval); 557 } 558 559 static int 560 tnf_getstate(caddr_t arg, int mode) 561 { 562 tifiocstate_t tstate; 563 proc_t *procp; 564 565 if (tnf_buf == NULL) { 566 tstate.buffer_state = TIFIOCBUF_NONE; 567 tstate.buffer_size = 0; 568 } else { 569 switch (tnfw_b_state & ~TNFW_B_STOPPED) { 570 case TNFW_B_RUNNING: 571 tstate.buffer_state = TIFIOCBUF_OK; 572 break; 573 case TNFW_B_NOBUFFER: 574 tstate.buffer_state = TIFIOCBUF_UNINIT; 575 break; 576 case TNFW_B_BROKEN: 577 tstate.buffer_state = TIFIOCBUF_BROKEN; 578 break; 579 } 580 /* LINTED assignment of 64-bit integer to 32-bit integer */ 581 tstate.buffer_size = tnf_trace_file_size; 582 } 583 tstate.trace_stopped = tnfw_b_state & TNFW_B_STOPPED; 584 tstate.pidfilter_mode = tnf_drv_state.tnf_pidfilter_mode; 585 tstate.pidfilter_size = 0; 586 587 mutex_enter(&pidlock); 588 for (procp = practive; procp != NULL; procp = procp->p_next) 589 if (PROC_IS_FILTER(procp)) 590 tstate.pidfilter_size++; 591 mutex_exit(&pidlock); 592 593 if (ddi_copyout((caddr_t)&tstate, arg, sizeof (tstate), mode)) 594 return (EFAULT); 595 return (0); 596 } 597 598 static int 599 tnf_allocbuf(intptr_t arg) 600 { 601 size_t bufsz; 602 603 if (tnf_buf != NULL) 604 return (EBUSY); 605 606 bufsz = roundup((size_t)arg, PAGESIZE); 607 /* 608 * Validate size 609 * XXX Take kernel VM into consideration as well 610 */ 611 /* bug fix #4057599 if (bufsz > (physmem << PAGESHIFT) / 2) */ 612 if (btop(bufsz) > (physmem / 2)) 613 return (ENOMEM); 614 if (bufsz < TNF_TRACE_FILE_MIN) 615 bufsz = TNF_TRACE_FILE_MIN; 616 617 #if TNF_USE_KMA 618 tnf_buf = kmem_zalloc(bufsz, KM_SLEEP); 619 #else 620 /* LINTED cast from 64-bit integer to 32-bit intege */ 621 tnf_buf = segkp_get(segkp, (int)bufsz, 622 KPD_ZERO | KPD_LOCKED | KPD_NO_ANON); 623 #endif 624 if (tnf_buf == NULL) 625 return (ENOMEM); 626 627 tnf_trace_file_size = bufsz; 628 tnf_trace_init(); 629 return (0); 630 } 631 632 /* 633 * Process a "deallocate buffer" ioctl request. Tracing must be turned 634 * off. We must clear references to the buffer from the tag sites; 635 * invalidate all threads' notions of block ownership; make sure nobody 636 * is executing a probe (they might have started before tracing was 637 * turned off); and free the buffer. 638 */ 639 static int 640 tnf_deallocbuf(void) 641 { 642 tnf_ops_t *tpdp; 643 kthread_t *t; 644 tnf_probe_control_t *probep; 645 tnf_tag_data_t *tagp; 646 647 if (tnf_drv_state.mapdev_open_count > 0 || tnf_tracing_active) 648 return (EBUSY); 649 if (tnf_buf == NULL) 650 return (ENOMEM); 651 652 /* 653 * Make sure nobody is executing a probe. 654 * (They could be if they got started while 655 * tnf_tracing_active was still on.) Grab 656 * pidlock, and check the busy flag in all 657 * TPDP's. 658 */ 659 mutex_enter(&pidlock); 660 t = curthread; 661 do { 662 if (t->t_tnf_tpdp != NULL) { 663 /* LINTED pointer cast may result in improper alignment */ 664 tpdp = (tnf_ops_t *)t->t_tnf_tpdp; 665 if (LOCK_HELD(&tpdp->busy)) { 666 mutex_exit(&pidlock); 667 return (EBUSY); 668 } 669 tpdp->wcb.tnfw_w_pos.tnfw_w_block = NULL; 670 tpdp->wcb.tnfw_w_tag_pos.tnfw_w_block = NULL; 671 tpdp->schedule.record_p = NULL; 672 } 673 t = t->t_next; 674 } while (t != curthread); 675 mutex_exit(&pidlock); 676 677 /* 678 * Zap all references to the buffer we're freeing. 679 * Grab mod_lock while walking list to keep it 680 * consistent. 681 */ 682 mutex_enter(&mod_lock); 683 tagp = (tnf_tag_data_t *)__tnf_tag_list_head; 684 while (tagp != NULL) { 685 tagp->tag_index = 0; 686 tagp = (tnf_tag_data_t *)tagp->tag_version; 687 } 688 probep = (tnf_probe_control_t *)__tnf_probe_list_head; 689 while (probep != NULL) { 690 probep->index = 0; 691 probep = probep->next; 692 } 693 mutex_exit(&mod_lock); 694 695 tnfw_b_state = TNFW_B_NOBUFFER | TNFW_B_STOPPED; 696 #if TNF_USE_KMA 697 kmem_free(tnf_buf, tnf_trace_file_size); 698 #else 699 segkp_release(segkp, tnf_buf); 700 #endif 701 tnf_buf = NULL; 702 703 return (0); 704 } 705 706 static int 707 tnf_settracing(int arg) 708 { 709 if (arg) 710 if (tnf_buf == NULL) 711 return (ENOMEM); 712 else 713 tnf_trace_on(); 714 else 715 tnf_trace_off(); 716 717 #ifdef _TNF_SPEED_TEST 718 #define NITER 255 719 { 720 int i; 721 722 for (i = 0; i < NITER; i++) 723 TNF_PROBE_0(tnf_speed_0, "tnf", /* CSTYLED */); 724 for (i = 0; i < NITER; i++) 725 TNF_PROBE_1(tnf_speed_1, "tnf", /* CSTYLED */, 726 tnf_long, long, i); 727 for (i = 0; i < NITER; i++) 728 TNF_PROBE_2(tnf_speed_2, "tnf", /* CSTYLED */, 729 tnf_long, long1, i, 730 tnf_long, long2, i); 731 } 732 #endif /* _TNF_SPEED_TEST */ 733 734 return (0); 735 } 736 737 static int 738 tnf_getpidstate(caddr_t arg, int mode) 739 { 740 int err = 0; 741 pid_t pid; 742 proc_t *procp; 743 int result; 744 745 if (ddi_copyin(arg, (caddr_t)&pid, sizeof (pid), mode)) 746 return (EFAULT); 747 748 mutex_enter(&pidlock); 749 if ((procp = prfind(pid)) != NULL) 750 result = PROC_IS_FILTER(procp); 751 else 752 err = ESRCH; 753 mutex_exit(&pidlock); 754 755 if (!err) 756 if (ddi_copyout((caddr_t)&result, (caddr_t)arg, 757 sizeof (result), mode)) 758 return (EFAULT); 759 return (err); 760 } 761 762 /*ARGSUSED*/ 763 static int 764 tnf_setpidstate(int filterval, pid_t pid, int mode) 765 { 766 int err = 0; 767 proc_t *procp; 768 769 mutex_enter(&pidlock); 770 if ((procp = prfind(pid)) != NULL) 771 if (filterval) 772 PROC_FILTER_SET(procp); 773 else 774 PROC_FILTER_CLR(procp); 775 else 776 err = ESRCH; 777 mutex_exit(&pidlock); 778 779 return (err); 780 } 781 782 static int 783 tnf_pidfilterset(int mode) 784 { 785 tnf_probe_control_t *p; 786 tnf_probe_test_func_t func; 787 788 tnf_drv_state.tnf_pidfilter_mode = mode; 789 790 /* Establish correct test func for each probe */ 791 if (mode) 792 func = tnf_test_2; 793 else 794 func = tnf_test_1; 795 796 mutex_enter(&mod_lock); 797 p = (tnf_probe_control_t *)__tnf_probe_list_head; 798 while (p != NULL) { 799 if (p->test_func != NULL) 800 p->test_func = func; 801 p = p->next; 802 } 803 mutex_exit(&mod_lock); 804 805 return (0); 806 } 807 808 static int 809 tnf_pidfilterget(caddr_t dest, int mode) 810 { 811 int err = 0; 812 int filtercount = 0; 813 size_t sz; 814 pid_t *filterbuf, *bufp; 815 proc_t *procp; 816 817 /* Count how many processes in filter set (upper bound) */ 818 mutex_enter(&pidlock); 819 for (procp = practive; procp != NULL; procp = procp->p_next) 820 if (PROC_IS_FILTER(procp)) 821 filtercount++; 822 mutex_exit(&pidlock); 823 824 /* Allocate temp space to hold filter set (upper bound) */ 825 sz = sizeof (pid_t) * (filtercount + 1); 826 filterbuf = kmem_zalloc(sz, KM_SLEEP); 827 828 /* 829 * NOTE: The filter set cannot grow between the first and 830 * second acquisitions of pidlock. This is currently true 831 * because: 832 * 1. /dev/tnfctl is exclusive open, so all driver 833 * control operations, including changing the filter 834 * set and this code, are effectively single-threaded. 835 * 2. There is no in-kernel API to manipulate the filter 836 * set (i.e. toggle the on/off bit in a proc struct). 837 * 3. The proc filter bit is not inherited across a fork() 838 * operation; the child starts with the bit off. 839 * If any of these assumptions is invalidated, a possible 840 * solution is to check whether we're overflowing the allocated 841 * filterbuf below, and back out and restart from the beginning 842 * if so. 843 * 844 * The code below handles the case when the filter set shrinks 845 * due to processes exiting. 846 */ 847 848 /* Fill in filter set */ 849 bufp = filterbuf + 1; /* first word is for count */ 850 filtercount = 0; /* recomputed below */ 851 mutex_enter(&pidlock); 852 for (procp = practive; procp != NULL; procp = procp->p_next) { 853 if (PROC_IS_FILTER(procp)) { 854 filtercount++; 855 *bufp++ = procp->p_pid; 856 } 857 } 858 mutex_exit(&pidlock); 859 860 /* Set filtercount */ 861 *filterbuf = (pid_t)filtercount; 862 863 /* Copy out result */ 864 if (ddi_copyout((caddr_t)filterbuf, dest, sz, mode)) 865 err = EFAULT; 866 867 /* Free temp space */ 868 kmem_free(filterbuf, sz); 869 870 return (err); 871 } 872 873 static int 874 tnf_getheader(caddr_t arg, int mode) 875 { 876 if (tnf_buf == NULL) 877 return (ENOMEM); 878 if (ddi_copyout(tnf_buf, arg, TNF_BLOCK_SIZE, mode)) 879 return (EFAULT); 880 return (0); 881 } 882 883 static int 884 tnf_getblock(caddr_t arg, int mode) 885 { 886 int err = 0; 887 tifiocgblock_t parms; 888 caddr_t area; 889 tnf_block_header_t *blk; 890 891 if (tnf_buf == NULL) 892 return (ENOMEM); 893 if (ddi_copyin(arg, (caddr_t)&parms, sizeof (parms), mode)) 894 return (EFAULT); 895 area = tnf_buf + TNF_DIRECTORY_SIZE + 896 parms.block_num * TNF_BLOCK_SIZE; 897 if (area < tnf_buf + TNF_DIRECTORY_SIZE || 898 area >= tnf_buf + tnf_trace_file_size) 899 return (EFAULT); 900 /* LINTED pointer cast */ 901 blk = (tnf_block_header_t *)area; 902 /* 903 * B-lock the block while we're reading 904 */ 905 if (!lock_try(&blk->B_lock)) 906 return (EBUSY); 907 if (ddi_copyout(area, parms.dst_addr, TNF_BLOCK_SIZE, mode)) 908 err = EFAULT; 909 lock_clear(&blk->B_lock); 910 return (err); 911 } 912 913 static int 914 tnf_getfwzone(caddr_t arg, int mode) 915 { 916 tifiocgfw_t parms; 917 918 if (tnf_buf == NULL) 919 return (ENOMEM); 920 if (ddi_copyin(arg, (caddr_t)&parms, sizeof (parms), mode)) 921 return (EFAULT); 922 if (ddi_copyout(tnf_buf + TNF_BLOCK_SIZE + parms.start * 923 sizeof (tnf_ref32_t), (caddr_t)parms.dst_addr, 924 parms.slots * (int)(sizeof (tnf_ref32_t)), mode)) 925 return (EFAULT); 926 return (0); 927 } 928 929 /*ARGSUSED*/ 930 static void * 931 tnf_test_1(void *tpdp, tnf_probe_control_t *probe_p, tnf_probe_setup_t *sp) 932 { 933 tpdp = (void *)curthread->t_tnf_tpdp; 934 if (tpdp != NULL) 935 return (tnf_trace_alloc((tnf_ops_t *)tpdp, probe_p, sp)); 936 return (NULL); 937 } 938 939 /*ARGSUSED*/ 940 static void * 941 tnf_test_2(void *tpdp, tnf_probe_control_t *probe_p, tnf_probe_setup_t *sp) 942 { 943 tpdp = (void *)curthread->t_tnf_tpdp; 944 if (tpdp != NULL && PROC_IS_FILTER(curproc)) 945 return (tnf_trace_alloc((tnf_ops_t *)tpdp, probe_p, sp)); 946 return (NULL); 947 } 948 949 #endif /* !NPROBE */ 950