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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26/* #pragma ident "@(#)fbt.c 1.18 07/01/10 SMI" */ 27 28#ifdef KERNEL 29#ifndef _KERNEL 30#define _KERNEL /* Solaris vs. Darwin */ 31#endif 32#endif 33 34#include <mach-o/loader.h> 35#include <libkern/kernel_mach_header.h> 36 37#include <sys/param.h> 38#include <sys/systm.h> 39#include <sys/errno.h> 40#include <sys/stat.h> 41#include <sys/ioctl.h> 42#include <sys/conf.h> 43#include <sys/fcntl.h> 44#include <miscfs/devfs/devfs.h> 45#include <pexpert/pexpert.h> 46 47#include <sys/dtrace.h> 48#include <sys/dtrace_impl.h> 49#include <sys/fbt.h> 50 51#include <sys/dtrace_glue.h> 52 53/* #include <machine/trap.h> */ 54struct savearea_t; /* Used anonymously */ 55 56typedef kern_return_t (*perfCallback)(int, struct savearea_t *, uintptr_t *, __unused int); 57extern perfCallback tempDTraceTrapHook; 58extern kern_return_t fbt_perfCallback(int, struct savearea_t *, uintptr_t *, __unused int); 59 60#define FBT_ADDR2NDX(addr) ((((uintptr_t)(addr)) >> 4) & fbt_probetab_mask) 61#define FBT_PROBETAB_SIZE 0x8000 /* 32k entries -- 128K total */ 62 63static dev_info_t *fbt_devi; 64static int fbt_probetab_size; 65dtrace_provider_id_t fbt_id; 66fbt_probe_t **fbt_probetab; 67int fbt_probetab_mask; 68static int fbt_verbose = 0; 69 70void fbt_init( void ); 71 72/*ARGSUSED*/ 73static void 74fbt_destroy(void *arg, dtrace_id_t id, void *parg) 75{ 76#pragma unused(arg,id) 77 fbt_probe_t *fbt = parg, *next, *hash, *last; 78 int ndx; 79 80 do { 81 /* 82 * Now we need to remove this probe from the fbt_probetab. 83 */ 84 ndx = FBT_ADDR2NDX(fbt->fbtp_patchpoint); 85 last = NULL; 86 hash = fbt_probetab[ndx]; 87 88 while (hash != fbt) { 89 ASSERT(hash != NULL); 90 last = hash; 91 hash = hash->fbtp_hashnext; 92 } 93 94 if (last != NULL) { 95 last->fbtp_hashnext = fbt->fbtp_hashnext; 96 } else { 97 fbt_probetab[ndx] = fbt->fbtp_hashnext; 98 } 99 100 next = fbt->fbtp_next; 101 kmem_free(fbt, sizeof (fbt_probe_t)); 102 103 fbt = next; 104 } while (fbt != NULL); 105} 106 107/*ARGSUSED*/ 108int 109fbt_enable(void *arg, dtrace_id_t id, void *parg) 110{ 111#pragma unused(arg,id) 112 fbt_probe_t *fbt = parg; 113 struct modctl *ctl = NULL; 114 115 for (; fbt != NULL; fbt = fbt->fbtp_next) { 116 117 ctl = fbt->fbtp_ctl; 118 119 if (!ctl->mod_loaded) { 120 if (fbt_verbose) { 121 cmn_err(CE_NOTE, "fbt is failing for probe %s " 122 "(module %s unloaded)", 123 fbt->fbtp_name, ctl->mod_modname); 124 } 125 126 continue; 127 } 128 129 /* 130 * Now check that our modctl has the expected load count. If it 131 * doesn't, this module must have been unloaded and reloaded -- and 132 * we're not going to touch it. 133 */ 134 if (ctl->mod_loadcnt != fbt->fbtp_loadcnt) { 135 if (fbt_verbose) { 136 cmn_err(CE_NOTE, "fbt is failing for probe %s " 137 "(module %s reloaded)", 138 fbt->fbtp_name, ctl->mod_modname); 139 } 140 141 continue; 142 } 143 144 dtrace_casptr(&tempDTraceTrapHook, NULL, fbt_perfCallback); 145 if (tempDTraceTrapHook != (perfCallback)fbt_perfCallback) { 146 if (fbt_verbose) { 147 cmn_err(CE_NOTE, "fbt_enable is failing for probe %s " 148 "in module %s: tempDTraceTrapHook already occupied.", 149 fbt->fbtp_name, ctl->mod_modname); 150 } 151 continue; 152 } 153 154 if (fbt->fbtp_currentval != fbt->fbtp_patchval) { 155 (void)ml_nofault_copy( (vm_offset_t)&fbt->fbtp_patchval, (vm_offset_t)fbt->fbtp_patchpoint, 156 sizeof(fbt->fbtp_patchval)); 157 fbt->fbtp_currentval = fbt->fbtp_patchval; 158 ctl->mod_nenabled++; 159 } 160 161 } 162 163 dtrace_membar_consumer(); 164 165 return (0); 166} 167 168/*ARGSUSED*/ 169static void 170fbt_disable(void *arg, dtrace_id_t id, void *parg) 171{ 172#pragma unused(arg,id) 173 fbt_probe_t *fbt = parg; 174 struct modctl *ctl = NULL; 175 176 for (; fbt != NULL; fbt = fbt->fbtp_next) { 177 ctl = fbt->fbtp_ctl; 178 179 if (!ctl->mod_loaded || (ctl->mod_loadcnt != fbt->fbtp_loadcnt)) 180 continue; 181 182 if (fbt->fbtp_currentval != fbt->fbtp_savedval) { 183 (void)ml_nofault_copy( (vm_offset_t)&fbt->fbtp_savedval, (vm_offset_t)fbt->fbtp_patchpoint, 184 sizeof(fbt->fbtp_savedval)); 185 fbt->fbtp_currentval = fbt->fbtp_savedval; 186 ASSERT(ctl->mod_nenabled > 0); 187 ctl->mod_nenabled--; 188 } 189 } 190 dtrace_membar_consumer(); 191} 192 193/*ARGSUSED*/ 194static void 195fbt_suspend(void *arg, dtrace_id_t id, void *parg) 196{ 197#pragma unused(arg,id) 198 fbt_probe_t *fbt = parg; 199 struct modctl *ctl = NULL; 200 201 for (; fbt != NULL; fbt = fbt->fbtp_next) { 202 ctl = fbt->fbtp_ctl; 203 204 ASSERT(ctl->mod_nenabled > 0); 205 if (!ctl->mod_loaded || (ctl->mod_loadcnt != fbt->fbtp_loadcnt)) 206 continue; 207 208 (void)ml_nofault_copy( (vm_offset_t)&fbt->fbtp_savedval, (vm_offset_t)fbt->fbtp_patchpoint, 209 sizeof(fbt->fbtp_savedval)); 210 211 212 fbt->fbtp_currentval = fbt->fbtp_savedval; 213 } 214 215 dtrace_membar_consumer(); 216} 217 218/*ARGSUSED*/ 219static void 220fbt_resume(void *arg, dtrace_id_t id, void *parg) 221{ 222#pragma unused(arg,id) 223 fbt_probe_t *fbt = parg; 224 struct modctl *ctl = NULL; 225 226 for (; fbt != NULL; fbt = fbt->fbtp_next) { 227 ctl = fbt->fbtp_ctl; 228 229 ASSERT(ctl->mod_nenabled > 0); 230 if (!ctl->mod_loaded || (ctl->mod_loadcnt != fbt->fbtp_loadcnt)) 231 continue; 232 233 dtrace_casptr(&tempDTraceTrapHook, NULL, fbt_perfCallback); 234 if (tempDTraceTrapHook != (perfCallback)fbt_perfCallback) { 235 if (fbt_verbose) { 236 cmn_err(CE_NOTE, "fbt_resume is failing for probe %s " 237 "in module %s: tempDTraceTrapHook already occupied.", 238 fbt->fbtp_name, ctl->mod_modname); 239 } 240 return; 241 } 242 243 (void)ml_nofault_copy( (vm_offset_t)&fbt->fbtp_patchval, (vm_offset_t)fbt->fbtp_patchpoint, 244 sizeof(fbt->fbtp_patchval)); 245 246 247 fbt->fbtp_currentval = fbt->fbtp_patchval; 248 } 249 250 dtrace_membar_consumer(); 251} 252 253#if !defined(__APPLE__) 254/*ARGSUSED*/ 255static void 256fbt_getargdesc(void *arg, dtrace_id_t id, void *parg, dtrace_argdesc_t *desc) 257{ 258 fbt_probe_t *fbt = parg; 259 struct modctl *ctl = fbt->fbtp_ctl; 260 struct module *mp = ctl->mod_mp; 261 ctf_file_t *fp = NULL, *pfp; 262 ctf_funcinfo_t f; 263 int error; 264 ctf_id_t argv[32], type; 265 int argc = sizeof (argv) / sizeof (ctf_id_t); 266 const char *parent; 267 268 if (!ctl->mod_loaded || (ctl->mod_loadcnt != fbt->fbtp_loadcnt)) 269 goto err; 270 271 if (fbt->fbtp_roffset != 0 && desc->dtargd_ndx == 0) { 272 (void) strlcpy(desc->dtargd_native, "int", 273 sizeof(desc->dtargd_native)); 274 return; 275 } 276 277 if ((fp = ctf_modopen(mp, &error)) == NULL) { 278 /* 279 * We have no CTF information for this module -- and therefore 280 * no args[] information. 281 */ 282 goto err; 283 } 284 285 /* 286 * If we have a parent container, we must manually import it. 287 */ 288 if ((parent = ctf_parent_name(fp)) != NULL) { 289 struct modctl *mp = &modules; 290 struct modctl *mod = NULL; 291 292 /* 293 * We must iterate over all modules to find the module that 294 * is our parent. 295 */ 296 do { 297 if (strcmp(mp->mod_modname, parent) == 0) { 298 mod = mp; 299 break; 300 } 301 } while ((mp = mp->mod_next) != &modules); 302 303 if (mod == NULL) 304 goto err; 305 306 if ((pfp = ctf_modopen(mod->mod_mp, &error)) == NULL) { 307 goto err; 308 } 309 310 if (ctf_import(fp, pfp) != 0) { 311 ctf_close(pfp); 312 goto err; 313 } 314 315 ctf_close(pfp); 316 } 317 318 if (ctf_func_info(fp, fbt->fbtp_symndx, &f) == CTF_ERR) 319 goto err; 320 321 if (fbt->fbtp_roffset != 0) { 322 if (desc->dtargd_ndx > 1) 323 goto err; 324 325 ASSERT(desc->dtargd_ndx == 1); 326 type = f.ctc_return; 327 } else { 328 if (desc->dtargd_ndx + 1 > f.ctc_argc) 329 goto err; 330 331 if (ctf_func_args(fp, fbt->fbtp_symndx, argc, argv) == CTF_ERR) 332 goto err; 333 334 type = argv[desc->dtargd_ndx]; 335 } 336 337 if (ctf_type_name(fp, type, desc->dtargd_native, 338 DTRACE_ARGTYPELEN) != NULL) { 339 ctf_close(fp); 340 return; 341 } 342err: 343 if (fp != NULL) 344 ctf_close(fp); 345 346 desc->dtargd_ndx = DTRACE_ARGNONE; 347} 348#endif /* __APPLE__ */ 349 350static dtrace_pattr_t fbt_attr = { 351{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_ISA }, 352{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN }, 353{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN }, 354{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_ISA }, 355{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA }, 356}; 357 358static dtrace_pops_t fbt_pops = { 359 NULL, 360 fbt_provide_module, 361 fbt_enable, 362 fbt_disable, 363 fbt_suspend, 364 fbt_resume, 365#if !defined(__APPLE__) 366 fbt_getargdesc, 367#else 368 NULL, /* FIXME: where to look for xnu? */ 369#endif /* __APPLE__ */ 370 NULL, 371 NULL, 372 fbt_destroy 373}; 374 375static void 376fbt_cleanup(dev_info_t *devi) 377{ 378 dtrace_invop_remove(fbt_invop); 379 ddi_remove_minor_node(devi, NULL); 380 kmem_free(fbt_probetab, fbt_probetab_size * sizeof (fbt_probe_t *)); 381 fbt_probetab = NULL; 382 fbt_probetab_mask = 0; 383} 384 385static int 386fbt_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) 387{ 388 switch (cmd) { 389 case DDI_ATTACH: 390 break; 391 case DDI_RESUME: 392 return (DDI_SUCCESS); 393 default: 394 return (DDI_FAILURE); 395 } 396 397 if (fbt_probetab_size == 0) 398 fbt_probetab_size = FBT_PROBETAB_SIZE; 399 400 fbt_probetab_mask = fbt_probetab_size - 1; 401 fbt_probetab = 402 kmem_zalloc(fbt_probetab_size * sizeof (fbt_probe_t *), KM_SLEEP); 403 404 dtrace_invop_add(fbt_invop); 405 406#if !defined(__APPLE__) 407 if (ddi_create_minor_node(devi, "fbt", S_IFCHR, 0, 408 DDI_PSEUDO, NULL) == DDI_FAILURE || 409 dtrace_register("fbt", &fbt_attr, DTRACE_PRIV_KERNEL, NULL, 410 &fbt_pops, NULL, &fbt_id) != 0) { 411 fbt_cleanup(devi); 412 return (DDI_FAILURE); 413 } 414#else 415 if (ddi_create_minor_node(devi, "fbt", S_IFCHR, 0, 416 DDI_PSEUDO, 0) == DDI_FAILURE || 417 dtrace_register("fbt", &fbt_attr, DTRACE_PRIV_KERNEL, NULL, 418 &fbt_pops, NULL, &fbt_id) != 0) { 419 fbt_cleanup(devi); 420 return (DDI_FAILURE); 421 } 422#endif /* __APPLE__ */ 423 424 ddi_report_dev(devi); 425 fbt_devi = devi; 426 427 return (DDI_SUCCESS); 428} 429 430static d_open_t _fbt_open; 431 432static int 433_fbt_open(dev_t dev, int flags, int devtype, struct proc *p) 434{ 435#pragma unused(dev,flags,devtype,p) 436 return 0; 437} 438 439#define FBT_MAJOR -24 /* let the kernel pick the device number */ 440 441/* 442 * A struct describing which functions will get invoked for certain 443 * actions. 444 */ 445static struct cdevsw fbt_cdevsw = 446{ 447 _fbt_open, /* open */ 448 eno_opcl, /* close */ 449 eno_rdwrt, /* read */ 450 eno_rdwrt, /* write */ 451 eno_ioctl, /* ioctl */ 452 (stop_fcn_t *)nulldev, /* stop */ 453 (reset_fcn_t *)nulldev, /* reset */ 454 NULL, /* tty's */ 455 eno_select, /* select */ 456 eno_mmap, /* mmap */ 457 eno_strat, /* strategy */ 458 eno_getc, /* getc */ 459 eno_putc, /* putc */ 460 0 /* type */ 461}; 462 463int gIgnoreFBTBlacklist = 0; 464static int gFBTInited = 0; 465#undef kmem_alloc /* from its binding to dt_kmem_alloc glue */ 466#undef kmem_free /* from its binding to dt_kmem_free glue */ 467#include <vm/vm_kern.h> 468 469void 470fbt_init( void ) 471{ 472 if (0 == gFBTInited) 473 { 474 int majdevno = cdevsw_add(FBT_MAJOR, &fbt_cdevsw); 475 476 if (majdevno < 0) { 477 printf("fbt_init: failed to allocate a major number!\n"); 478 return; 479 } 480 481 PE_parse_boot_argn("IgnoreFBTBlacklist", &gIgnoreFBTBlacklist, sizeof (gIgnoreFBTBlacklist)); 482 483 fbt_attach( (dev_info_t *)(uintptr_t)majdevno, DDI_ATTACH ); 484 485 gFBTInited = 1; /* Ensure this initialization occurs just one time. */ 486 } 487 else 488 panic("fbt_init: called twice!\n"); 489} 490#undef FBT_MAJOR 491