1/* 2 * Copyright (c) 2005-2006 Apple Computer, Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28 29#ifndef _DTRACE_GLUE_H 30#define _DTRACE_GLUE_H 31 32#ifdef KERNEL_BUILD 33 34#include <libkern/libkern.h> 35#include <kern/locks.h> 36#include <kern/thread_call.h> 37#include <kern/thread.h> 38#include <machine/machine_routines.h> 39#include <sys/syslog.h> 40#include <sys/ucred.h> 41#include <stdarg.h> 42#include <mach/kmod.h> 43#include <libkern/OSAtomic.h> 44 45#if defined(__i386__) || defined(__x86_64__) 46#include <i386/mp.h> 47#endif 48 49/* 50 * cmn_err 51 */ 52#define CE_CONT 0 /* continuation */ 53#define CE_NOTE 1 /* notice */ 54#define CE_WARN 2 /* warning */ 55#define CE_PANIC 3 /* panic */ 56#define CE_IGNORE 4 /* print nothing */ 57 58extern void cmn_err( int, const char *, ... ); 59 60/* 61 * pid/proc 62 */ 63 64/* Solaris proc_t is the struct. Darwin's proc_t is a pointer to it. */ 65#define proc_t struct proc /* Steer clear of the Darwin typedef for proc_t */ 66#define curproc ((struct proc *)current_proc()) /* Called from probe context, must blacklist */ 67 68proc_t* sprlock(pid_t pid); 69void sprunlock(proc_t *p); 70 71/* 72 * uread/uwrite 73 */ 74 75int uread(proc_t *p, void *buf, user_size_t len, user_addr_t a); 76int uwrite(proc_t *p, void *buf, user_size_t len, user_addr_t a); 77 78/* 79 * fuword / suword 80 */ 81 82int fuword8(user_addr_t, uint8_t *); 83int fuword16(user_addr_t, uint16_t *); 84int fuword32(user_addr_t, uint32_t *); 85int fuword64(user_addr_t, uint64_t *); 86 87void fuword8_noerr(user_addr_t, uint8_t *); 88void fuword16_noerr(user_addr_t, uint16_t *); 89void fuword32_noerr(user_addr_t, uint32_t *); 90void fuword64_noerr(user_addr_t, uint64_t *); 91 92int suword64(user_addr_t, uint64_t value); 93int suword32(user_addr_t, uint32_t value); 94int suword16(user_addr_t, uint16_t value); 95int suword8(user_addr_t, uint8_t value); 96 97/* 98 * cpuvar 99 */ 100extern lck_mtx_t cpu_lock; 101extern lck_mtx_t cyc_lock; 102extern lck_mtx_t mod_lock; 103 104/* 105 * wrap_timer_call: wrapper of timer_call for cyclic timers. 106 */ 107struct wrap_timer_call; 108 109/* 110 * Per-CPU data. 111 */ 112typedef struct dtrace_cpu { 113 processorid_t cpu_id; /* CPU number */ 114 struct dtrace_cpu *cpu_next; /* next existing CPU */ 115 lck_rw_t cpu_ft_lock; /* DTrace: fasttrap lock */ 116 uintptr_t cpu_dtrace_caller; /* DTrace: caller, if any */ 117 hrtime_t cpu_dtrace_chillmark; /* DTrace: chill mark time */ 118 hrtime_t cpu_dtrace_chilled; /* DTrace: total chill time */ 119 boolean_t cpu_dtrace_invop_underway; /* DTrace gaurds against invalid op re-entrancy */ 120 121 /* Local cyclic timers on this CPU */ 122 LIST_HEAD(cyc_list_head, wrap_timer_call) cpu_cyc_list; 123} dtrace_cpu_t; 124 125extern dtrace_cpu_t *cpu_list; 126 127/* 128 * The cpu_core structure consists of per-CPU state available in any context. 129 * On some architectures, this may mean that the page(s) containing the 130 * NCPU-sized array of cpu_core structures must be locked in the TLB -- it 131 * is up to the platform to assure that this is performed properly. Note that 132 * the structure is sized to avoid false sharing. 133 */ 134#define CPU_CACHE_COHERENCE_SIZE 64 135 136typedef struct cpu_core { 137 uint64_t cpuc_dtrace_illval; /* DTrace illegal value */ 138 lck_mtx_t cpuc_pid_lock; /* DTrace pid provider lock */ 139 uint16_t cpuc_dtrace_flags; /* DTrace flags */ 140 uint64_t cpuc_missing_tos; /* Addr. of top most stack frame if missing */ 141 uint8_t cpuc_pad[CPU_CACHE_COHERENCE_SIZE - sizeof(uint64_t) - sizeof(lck_mtx_t) - sizeof(uint16_t) - sizeof(uint64_t) ]; /* padding */ 142} cpu_core_t; 143 144extern cpu_core_t *cpu_core; 145 146extern unsigned int dtrace_max_cpus; /* max number of enabled cpus */ 147#define NCPU dtrace_max_cpus 148 149extern int cpu_number(void); /* From #include <kern/cpu_number.h>. Called from probe context, must blacklist. */ 150 151#define CPU (&(cpu_list[cpu_number()])) /* Pointer to current CPU */ 152#define CPU_ON_INTR(cpup) ml_at_interrupt_context() /* always invoked on current cpu */ 153 154/* 155 * Routines used to register interest in cpu's being added to or removed 156 * from the system. 157 */ 158typedef enum { 159 CPU_INIT, 160 CPU_CONFIG, 161 CPU_UNCONFIG, 162 CPU_ON, 163 CPU_OFF, 164 CPU_CPUPART_IN, 165 CPU_CPUPART_OUT 166} cpu_setup_t; 167 168typedef int cpu_setup_func_t(cpu_setup_t, int, void *); 169 170extern void register_cpu_setup_func(cpu_setup_func_t *, void *); 171extern void unregister_cpu_setup_func(cpu_setup_func_t *, void *); 172 173/* 174 * CPU_DTRACE 175 */ 176 177/* 178 * DTrace flags. 179 */ 180#define CPU_DTRACE_NOFAULT 0x0001 /* Don't fault */ 181#define CPU_DTRACE_DROP 0x0002 /* Drop this ECB */ 182#define CPU_DTRACE_BADADDR 0x0004 /* DTrace fault: bad address */ 183#define CPU_DTRACE_BADALIGN 0x0008 /* DTrace fault: bad alignment */ 184#define CPU_DTRACE_DIVZERO 0x0010 /* DTrace fault: divide by zero */ 185#define CPU_DTRACE_ILLOP 0x0020 /* DTrace fault: illegal operation */ 186#define CPU_DTRACE_NOSCRATCH 0x0040 /* DTrace fault: out of scratch */ 187#define CPU_DTRACE_KPRIV 0x0080 /* DTrace fault: bad kernel access */ 188#define CPU_DTRACE_UPRIV 0x0100 /* DTrace fault: bad user access */ 189#define CPU_DTRACE_TUPOFLOW 0x0200 /* DTrace fault: tuple stack overflow */ 190#define CPU_DTRACE_USTACK_FP 0x0400 /* pid provider hint to ustack() */ 191#define CPU_DTRACE_ENTRY 0x0800 /* pid provider hint to ustack() */ 192#define CPU_DTRACE_BADSTACK 0x1000 /* DTrace fault: bad stack */ 193 194#define CPU_DTRACE_FAULT (CPU_DTRACE_BADADDR | CPU_DTRACE_BADALIGN | \ 195 CPU_DTRACE_DIVZERO | CPU_DTRACE_ILLOP | \ 196 CPU_DTRACE_NOSCRATCH | CPU_DTRACE_KPRIV | \ 197 CPU_DTRACE_UPRIV | CPU_DTRACE_TUPOFLOW | \ 198 CPU_DTRACE_BADSTACK) 199#define CPU_DTRACE_ERROR (CPU_DTRACE_FAULT | CPU_DTRACE_DROP) 200 201/* 202 * Loadable Modules 203 */ 204 205/* Keep the compiler happy */ 206struct dtrace_module_symbols; 207 208/* Solaris' modctl structure, greatly simplified, shadowing parts of xnu kmod structure. */ 209typedef struct modctl { 210 struct modctl *mod_next; 211 struct modctl *mod_stale; // stale module chain 212 uint32_t mod_id; // the kext unique identifier 213 char mod_modname[KMOD_MAX_NAME]; 214 int mod_loadcnt; 215 char mod_loaded; 216 uint16_t mod_flags; // See flags below 217 int mod_nenabled; // # of enabled DTrace probes in module 218 vm_address_t mod_address; // starting address (of Mach-o header blob) 219 vm_size_t mod_size; // total size (of blob) 220 UUID mod_uuid; 221 struct dtrace_module_symbols* mod_user_symbols; 222} modctl_t; 223 224/* Definitions for mod_flags */ 225#define MODCTL_IS_MACH_KERNEL 0x01 // This module represents /mach_kernel 226#define MODCTL_HAS_KERNEL_SYMBOLS 0x02 // Kernel symbols (nlist) are available 227#define MODCTL_FBT_PROBES_PROVIDED 0x04 // fbt probes have been provided 228#define MODCTL_FBT_INVALID 0x08 // Module is invalid for fbt probes 229#define MODCTL_SDT_PROBES_PROVIDED 0x10 // sdt probes have been provided 230#define MODCTL_SDT_INVALID 0x20 // Module is invalid for sdt probes 231#define MODCTL_HAS_UUID 0x40 // Module has UUID 232#define MODCTL_FBT_PRIVATE_PROBES_PROVIDED 0x80 // fbt private probes have been provided 233#define MODCTL_FBT_PROVIDE_PRIVATE_PROBES 0x100 // fbt provider must provide private probes 234 235/* Simple/singular mod_flags accessors */ 236#define MOD_IS_MACH_KERNEL(mod) (mod->mod_flags & MODCTL_IS_MACH_KERNEL) 237#define MOD_HAS_KERNEL_SYMBOLS(mod) (mod->mod_flags & MODCTL_HAS_KERNEL_SYMBOLS) 238#define MOD_HAS_USERSPACE_SYMBOLS(mod) (mod->mod_user_symbols) /* No point in duplicating state in the flags bits */ 239#define MOD_FBT_PROBES_PROVIDED(mod) (mod->mod_flags & MODCTL_FBT_PROBES_PROVIDED) 240#define MOD_FBT_INVALID(mod) (mod->mod_flags & MODCTL_FBT_INVALID) 241#define MOD_SDT_PROBES_PROVIDED(mod) (mod->mod_flags & MODCTL_SDT_PROBES_PROVIDED) 242#define MOD_SDT_INVALID(mod) (mod->mod_flags & MODCTL_SDT_INVALID) 243#define MOD_HAS_UUID(mod) (mod->mod_flags & MODCTL_HAS_UUID) 244#define MOD_FBT_PRIVATE_PROBES_PROVIDED(mod) (mod->mod_flags & MODCTL_FBT_PRIVATE_PROBES_PROVIDED) 245#define MOD_FBT_PROVIDE_PRIVATE_PROBES(mod) (mod->mod_flags & MODCTL_FBT_PROVIDE_PRIVATE_PROBES) 246 247/* Compound accessors */ 248#define MOD_FBT_PRIVATE_PROBES_DONE(mod) (MOD_FBT_PRIVATE_PROBES_PROVIDED(mod) || !MOD_FBT_PROVIDE_PRIVATE_PROBES(mod)) 249#define MOD_FBT_DONE(mod) ((MOD_FBT_PROBES_PROVIDED(mod) && MOD_FBT_PRIVATE_PROBES_DONE(mod)) || MOD_FBT_INVALID(mod)) 250#define MOD_SDT_DONE(mod) (MOD_SDT_PROBES_PROVIDED(mod) || MOD_SDT_INVALID(mod)) 251#define MOD_SYMBOLS_DONE(mod) (MOD_FBT_DONE(mod) && MOD_SDT_DONE(mod)) 252 253extern modctl_t *dtrace_modctl_list; 254 255/* 256 * cred_t 257 */ 258/* Privileges */ 259#define PRIV_DTRACE_KERNEL 3 260#define PRIV_DTRACE_PROC 4 261#define PRIV_DTRACE_USER 5 262#define PRIV_PROC_OWNER 30 263#define PRIV_PROC_ZONE 35 264#define PRIV_ALL (-1) /* All privileges required */ 265 266/* Privilege sets */ 267#define PRIV_EFFECTIVE 0 268 269typedef struct ucred cred_t; 270#define cr_suid cr_svuid 271#define cr_sgid cr_svgid 272 273extern cred_t *dtrace_CRED(void); /* Safe to call from probe context. */ 274#define CRED() kauth_cred_get() /* Can't be called from probe context! */ 275extern int PRIV_POLICY_CHOICE(void *, int, int); 276extern int PRIV_POLICY_ONLY(void *, int, int); 277extern gid_t crgetgid(const cred_t *); 278extern uid_t crgetuid(const cred_t *); 279#define crgetzoneid(x) ((zoneid_t)0) 280 281#define crhold(a) {} 282#define crfree(a) {} 283 284/* 285 * "cyclic" 286 */ 287#define CY_LOW_LEVEL 0 288#define CY_LOCK_LEVEL 1 289#define CY_HIGH_LEVEL 2 290#define CY_SOFT_LEVELS 2 291#define CY_LEVELS 3 292 293typedef uintptr_t cyclic_id_t; 294typedef cyclic_id_t *cyclic_id_list_t; 295typedef uint16_t cyc_level_t; 296typedef void (*cyc_func_t)(void *); 297 298#define CYCLIC_NONE ((cyclic_id_t)0) 299 300typedef struct cyc_time { 301 hrtime_t cyt_when; 302 hrtime_t cyt_interval; 303} cyc_time_t; 304 305typedef struct cyc_handler { 306 cyc_func_t cyh_func; 307 void *cyh_arg; 308 cyc_level_t cyh_level; 309} cyc_handler_t; 310 311typedef struct cyc_omni_handler { 312 void (*cyo_online)(void *, dtrace_cpu_t *, cyc_handler_t *, cyc_time_t *); 313 void (*cyo_offline)(void *, dtrace_cpu_t *, void *); 314 void *cyo_arg; 315} cyc_omni_handler_t; 316 317extern void dtrace_install_cpu_hooks(void); 318 319extern cyclic_id_t cyclic_add(cyc_handler_t *, cyc_time_t *); 320extern void cyclic_remove(cyclic_id_t); 321 322extern cyclic_id_list_t cyclic_add_omni(cyc_omni_handler_t *); 323extern void cyclic_remove_omni(cyclic_id_list_t); 324 325extern cyclic_id_t cyclic_timer_add(cyc_handler_t *, cyc_time_t *); 326extern void cyclic_timer_remove(cyclic_id_t); 327 328/* 329 * timeout / untimeout (converted to dtrace_timeout / dtrace_untimeout due to name collision) 330 */ 331 332thread_call_t dtrace_timeout(void (*func)(void *, void *), void* arg, uint64_t nanos); 333 334/* 335 * ddi 336 */ 337 338#define DDI_SUCCESS 0 339#define DDI_FAILURE -1 340 341#define DDI_DEV_T_NONE ((dev_t)-1) 342#define DDI_DEV_T_ANY ((dev_t)-2) 343#define DDI_MAJOR_T_UNKNOWN ((major_t)0) 344 345#define DDI_PSEUDO "ddi_pseudo" 346 347typedef enum { 348 DDI_ATTACH = 0, 349 DDI_RESUME = 1, 350 DDI_PM_RESUME = 2 351} ddi_attach_cmd_t; 352 353typedef enum { 354 DDI_DETACH = 0, 355 DDI_SUSPEND = 1, 356 DDI_PM_SUSPEND = 2, 357 DDI_HOTPLUG_DETACH = 3 /* detach, don't try to auto-unconfig */ 358} ddi_detach_cmd_t; 359 360#define DDI_PROP_SUCCESS 0 361 362#define DDI_PROP_DONTPASS 1 363typedef uint_t major_t; 364typedef uint_t minor_t; 365 366typedef struct __dev_info *dev_info_t; 367 368extern void ddi_report_dev(dev_info_t *); 369extern int ddi_soft_state_init(void **, size_t, size_t); 370extern void *ddi_get_soft_state(void *, int); 371extern int ddi_soft_state_free(void *, int); 372extern int ddi_soft_state_zalloc(void *, int); 373extern void ddi_soft_state_fini(void **); 374 375int ddi_getprop(dev_t dev, dev_info_t *dip, int flags, const char *name, int defvalue); 376 377extern int ddi_prop_free(void *); 378extern int ddi_prop_lookup_int_array(dev_t, dev_info_t *, uint_t, const char *, int **, uint_t *); 379 380extern int ddi_driver_major(dev_info_t *); 381 382extern int ddi_create_minor_node(dev_info_t *, const char *, int, minor_t, const char *, int); 383extern void ddi_remove_minor_node(dev_info_t *, char *); 384 385extern major_t getemajor(dev_t); 386extern minor_t getminor(dev_t); 387 388extern dev_t makedevice(major_t, minor_t); 389 390/* 391 * Kernel Debug Interface 392 */ 393 394typedef enum kdi_dtrace_set { 395 KDI_DTSET_DTRACE_ACTIVATE, 396 KDI_DTSET_DTRACE_DEACTIVATE, 397 KDI_DTSET_KMDB_BPT_ACTIVATE, 398 KDI_DTSET_KMDB_BPT_DEACTIVATE 399} kdi_dtrace_set_t; 400 401extern int kdi_dtrace_set(kdi_dtrace_set_t); 402extern void debug_enter(char *); 403 404/* 405 * DTrace specific zone allocation 406 */ 407 408/* 409 * To break dtrace memory usage out in a trackable 410 * fashion, uncomment the #define below. This will 411 * enable emulation of the general kalloc.XXX zones 412 * for most dtrace allocations. (kalloc.large is not 413 * emulated) 414 * 415 * #define DTRACE_MEMORY_ZONES 1 416 * 417 */ 418 419#if defined(DTRACE_MEMORY_ZONES) 420void dtrace_alloc_init(void); 421void *dtrace_alloc(vm_size_t); 422void dtrace_free(void *, vm_size_t); 423#endif 424 425/* 426 * kmem 427 */ 428 429#define KM_SLEEP 0x00000000 430#define KM_NOSLEEP 0x00000001 431 432typedef struct vmem vmem_t; 433typedef struct kmem_cache kmem_cache_t; 434 435#define kmem_alloc dt_kmem_alloc /* Avoid clash with Darwin's kmem_alloc */ 436#define kmem_free dt_kmem_free /* Avoid clash with Darwin's kmem_free */ 437#define kmem_zalloc dt_kmem_zalloc /* Avoid clash with Darwin's kmem_zalloc */ 438extern void *dt_kmem_alloc(size_t, int); 439extern void dt_kmem_free(void *, size_t); 440extern void *dt_kmem_zalloc(size_t, int); 441 442extern void *dt_kmem_alloc_aligned(size_t, size_t, int); 443extern void *dt_kmem_zalloc_aligned(size_t, size_t, int); 444extern void dt_kmem_free_aligned(void*, size_t); 445 446extern kmem_cache_t * 447kmem_cache_create(const char *, size_t, size_t, int (*)(void *, void *, int), 448 void (*)(void *, void *), void (*)(void *), void *, vmem_t *, int); 449extern void *kmem_cache_alloc(kmem_cache_t *, int); 450extern void kmem_cache_free(kmem_cache_t *, void *); 451extern void kmem_cache_destroy(kmem_cache_t *); 452 453/* 454 * kthread 455 */ 456 457typedef struct _kthread kthread_t; /* For dtrace_vtime_switch(), dtrace_panicked and dtrace_errthread */ 458 459/* 460 * proc 461 */ 462 463#define DATAMODEL_MASK 0x0FF00000 464 465#define DATAMODEL_ILP32 0x00100000 466#define DATAMODEL_LP64 0x00200000 467 468#define DATAMODEL_NONE 0 469 470#if defined(__LP64__) 471#define DATAMODEL_NATIVE DATAMODEL_LP64 472#else 473#define DATAMODEL_NATIVE DATAMODEL_ILP32 474#endif /* __LP64__ */ 475 476typedef unsigned int model_t; /* For dtrace_instr_size_isa() prototype in <sys/dtrace.h> */ 477 478/* 479 * taskq 480 */ 481 482#define TQ_SLEEP 0x00 /* Can block for memory */ 483 484typedef uint_t pri_t; 485typedef struct taskq taskq_t; 486typedef void (task_func_t)(void *); 487typedef uintptr_t taskqid_t; 488 489extern taskq_t *taskq_create(const char *, int, pri_t, int, int, uint_t); 490extern taskqid_t taskq_dispatch(taskq_t *, task_func_t, void *, uint_t); 491extern void taskq_destroy(taskq_t *); 492 493extern pri_t maxclsyspri; 494 495/* 496 * vmem 497 */ 498 499#define VMC_IDENTIFIER 0x00040000 /* not backed by memory */ 500#define VM_SLEEP 0x00000000 /* same as KM_SLEEP */ 501#define VM_BESTFIT 0x00000100 502 503extern void *vmem_alloc(vmem_t *, size_t, int); 504extern vmem_t *vmem_create(const char *, void *, size_t, size_t, void *, 505 void *, vmem_t *, size_t, int); 506extern void vmem_destroy(vmem_t *); 507extern void vmem_free(vmem_t *vmp, void *vaddr, size_t size); 508 509/* 510 * Atomic 511 */ 512 513static inline void atomic_add_32( uint32_t *theAddress, int32_t theAmount ) 514{ 515 (void)OSAddAtomic( theAmount, theAddress ); 516} 517 518#if defined(__i386__) || defined(__x86_64__) 519static inline void atomic_add_64( uint64_t *theAddress, int64_t theAmount ) 520{ 521 (void)OSAddAtomic64( theAmount, (SInt64 *)theAddress ); 522} 523#endif 524 525/* 526 * Miscellaneous 527 */ 528 529typedef uintptr_t pc_t; 530typedef uintptr_t greg_t; /* For dtrace_impl.h prototype of dtrace_getfp() */ 531extern struct regs *find_user_regs( thread_t thread); 532extern vm_offset_t dtrace_get_cpu_int_stack_top(void); 533extern vm_offset_t max_valid_stack_address(void); /* kern/thread.h */ 534 535extern volatile int panicwait; /* kern/debug.c */ 536#define panic_quiesce (panicwait) 537 538#define IS_P2ALIGNED(v, a) ((((uintptr_t)(v)) & ((uintptr_t)(a) - 1)) == 0) 539 540extern void delay( int ); /* kern/clock.h */ 541 542extern int vuprintf(const char *, va_list); 543 544extern hrtime_t dtrace_abs_to_nano(uint64_t); 545 546__private_extern__ const char * strstr(const char *, const char *); 547 548#undef proc_t 549 550/* 551 * Safe counted string compare against a literal string. The sizeof() intentionally 552 * counts the trailing NUL, and so ensures that all the characters in the literal 553 * can participate in the comparison. 554 */ 555#define LIT_STRNEQL(s1, lit_s2) (0 == strncmp( (s1), (lit_s2), sizeof((lit_s2)) )) 556 557/* 558 * Safe counted string compare of a literal against the beginning of a string. Here 559 * the sizeof() is reduced by 1 so that the trailing null of the literal does not 560 * participate in the comparison. 561 */ 562#define LIT_STRNSTART(s1, lit_s2) (0 == strncmp( (s1), (lit_s2), sizeof((lit_s2)) - 1 )) 563 564#define KERNELBASE VM_MIN_KERNEL_ADDRESS 565#endif /* KERNEL_BUILD */ 566#endif /* _DTRACE_GLUE_H */ 567 568