23 * 24 */ 25/* 26 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 27 * Use is subject to license terms. 28 */ 29 30#include <sys/param.h> 31#include <sys/systm.h> 32#include <sys/types.h> 33#include <sys/kernel.h> 34#include <sys/malloc.h> 35#include <sys/kmem.h> 36#include <sys/smp.h> 37#include <sys/dtrace_impl.h> 38#include <sys/dtrace_bsd.h> 39#include <machine/clock.h> 40#include <machine/frame.h> 41#include <vm/pmap.h> 42 43extern uintptr_t dtrace_in_probe_addr; 44extern int dtrace_in_probe; 45 46int dtrace_invop(uintptr_t, uintptr_t *, uintptr_t); 47 48typedef struct dtrace_invop_hdlr { 49 int (*dtih_func)(uintptr_t, uintptr_t *, uintptr_t); 50 struct dtrace_invop_hdlr *dtih_next; 51} dtrace_invop_hdlr_t; 52 53dtrace_invop_hdlr_t *dtrace_invop_hdlr; 54 55int 56dtrace_invop(uintptr_t addr, uintptr_t *stack, uintptr_t eax) 57{ 58 dtrace_invop_hdlr_t *hdlr; 59 int rval; 60 61 for (hdlr = dtrace_invop_hdlr; hdlr != NULL; hdlr = hdlr->dtih_next) 62 if ((rval = hdlr->dtih_func(addr, stack, eax)) != 0) 63 return (rval); 64 65 return (0); 66} 67 68void 69dtrace_invop_add(int (*func)(uintptr_t, uintptr_t *, uintptr_t)) 70{ 71 dtrace_invop_hdlr_t *hdlr; 72 73 hdlr = kmem_alloc(sizeof (dtrace_invop_hdlr_t), KM_SLEEP); 74 hdlr->dtih_func = func; 75 hdlr->dtih_next = dtrace_invop_hdlr; 76 dtrace_invop_hdlr = hdlr; 77} 78 79void 80dtrace_invop_remove(int (*func)(uintptr_t, uintptr_t *, uintptr_t)) 81{ 82 dtrace_invop_hdlr_t *hdlr = dtrace_invop_hdlr, *prev = NULL; 83 84 for (;;) { 85 if (hdlr == NULL) 86 panic("attempt to remove non-existent invop handler"); 87 88 if (hdlr->dtih_func == func) 89 break; 90 91 prev = hdlr; 92 hdlr = hdlr->dtih_next; 93 } 94 95 if (prev == NULL) { 96 ASSERT(dtrace_invop_hdlr == hdlr); 97 dtrace_invop_hdlr = hdlr->dtih_next; 98 } else { 99 ASSERT(dtrace_invop_hdlr != hdlr); 100 prev->dtih_next = hdlr->dtih_next; 101 } 102 103 kmem_free(hdlr, 0); 104} 105 106/*ARGSUSED*/ 107void 108dtrace_toxic_ranges(void (*func)(uintptr_t base, uintptr_t limit)) 109{ 110 (*func)(0, (uintptr_t) addr_PTmap); 111} 112 113void 114dtrace_xcall(processorid_t cpu, dtrace_xcall_t func, void *arg) 115{ 116 cpumask_t cpus; 117 118 critical_enter(); 119 120 if (cpu == DTRACE_CPUALL) 121 cpus = all_cpus; 122 else 123 cpus = (cpumask_t) (1 << cpu); 124 125 /* If the current CPU is in the set, call the function directly: */ 126 if ((cpus & (1 << curcpu)) != 0) { 127 (*func)(arg); 128 129 /* Mask the current CPU from the set */ 130 cpus &= ~(1 << curcpu); 131 } 132 133 /* If there are any CPUs in the set, cross-call to those CPUs */ 134 if (cpus != 0) 135 smp_rendezvous_cpus(cpus, NULL, func, smp_no_rendevous_barrier, arg); 136 137 critical_exit(); 138} 139 140static void 141dtrace_sync_func(void) 142{ 143} 144 145void 146dtrace_sync(void) 147{ 148 dtrace_xcall(DTRACE_CPUALL, (dtrace_xcall_t)dtrace_sync_func, NULL); 149} 150 151#ifdef notyet 152int (*dtrace_fasttrap_probe_ptr)(struct regs *); 153int (*dtrace_pid_probe_ptr)(struct regs *); 154int (*dtrace_return_probe_ptr)(struct regs *); 155 156void 157dtrace_user_probe(struct regs *rp, caddr_t addr, processorid_t cpuid) 158{ 159 krwlock_t *rwp; 160 proc_t *p = curproc; 161 extern void trap(struct regs *, caddr_t, processorid_t); 162 163 if (USERMODE(rp->r_cs) || (rp->r_ps & PS_VM)) { 164 if (curthread->t_cred != p->p_cred) { 165 cred_t *oldcred = curthread->t_cred; 166 /* 167 * DTrace accesses t_cred in probe context. t_cred 168 * must always be either NULL, or point to a valid, 169 * allocated cred structure. 170 */ 171 curthread->t_cred = crgetcred(); 172 crfree(oldcred); 173 } 174 } 175 176 if (rp->r_trapno == T_DTRACE_RET) { 177 uint8_t step = curthread->t_dtrace_step; 178 uint8_t ret = curthread->t_dtrace_ret; 179 uintptr_t npc = curthread->t_dtrace_npc; 180 181 if (curthread->t_dtrace_ast) { 182 aston(curthread); 183 curthread->t_sig_check = 1; 184 } 185 186 /* 187 * Clear all user tracing flags. 188 */ 189 curthread->t_dtrace_ft = 0; 190 191 /* 192 * If we weren't expecting to take a return probe trap, kill 193 * the process as though it had just executed an unassigned 194 * trap instruction. 195 */ 196 if (step == 0) { 197 tsignal(curthread, SIGILL); 198 return; 199 } 200 201 /* 202 * If we hit this trap unrelated to a return probe, we're 203 * just here to reset the AST flag since we deferred a signal 204 * until after we logically single-stepped the instruction we 205 * copied out. 206 */ 207 if (ret == 0) { 208 rp->r_pc = npc; 209 return; 210 } 211 212 /* 213 * We need to wait until after we've called the 214 * dtrace_return_probe_ptr function pointer to set %pc. 215 */ 216 rwp = &CPU->cpu_ft_lock; 217 rw_enter(rwp, RW_READER); 218 if (dtrace_return_probe_ptr != NULL) 219 (void) (*dtrace_return_probe_ptr)(rp); 220 rw_exit(rwp); 221 rp->r_pc = npc; 222 223 } else if (rp->r_trapno == T_DTRACE_PROBE) { 224 rwp = &CPU->cpu_ft_lock; 225 rw_enter(rwp, RW_READER); 226 if (dtrace_fasttrap_probe_ptr != NULL) 227 (void) (*dtrace_fasttrap_probe_ptr)(rp); 228 rw_exit(rwp); 229 230 } else if (rp->r_trapno == T_BPTFLT) { 231 uint8_t instr; 232 rwp = &CPU->cpu_ft_lock; 233 234 /* 235 * The DTrace fasttrap provider uses the breakpoint trap 236 * (int 3). We let DTrace take the first crack at handling 237 * this trap; if it's not a probe that DTrace knowns about, 238 * we call into the trap() routine to handle it like a 239 * breakpoint placed by a conventional debugger. 240 */ 241 rw_enter(rwp, RW_READER); 242 if (dtrace_pid_probe_ptr != NULL && 243 (*dtrace_pid_probe_ptr)(rp) == 0) { 244 rw_exit(rwp); 245 return; 246 } 247 rw_exit(rwp); 248 249 /* 250 * If the instruction that caused the breakpoint trap doesn't 251 * look like an int 3 anymore, it may be that this tracepoint 252 * was removed just after the user thread executed it. In 253 * that case, return to user land to retry the instuction. 254 */ 255 if (fuword8((void *)(rp->r_pc - 1), &instr) == 0 && 256 instr != FASTTRAP_INSTR) { 257 rp->r_pc--; 258 return; 259 } 260 261 trap(rp, addr, cpuid); 262 263 } else { 264 trap(rp, addr, cpuid); 265 } 266} 267 268void 269dtrace_safe_synchronous_signal(void) 270{ 271 kthread_t *t = curthread; 272 struct regs *rp = lwptoregs(ttolwp(t)); 273 size_t isz = t->t_dtrace_npc - t->t_dtrace_pc; 274 275 ASSERT(t->t_dtrace_on); 276 277 /* 278 * If we're not in the range of scratch addresses, we're not actually 279 * tracing user instructions so turn off the flags. If the instruction 280 * we copied out caused a synchonous trap, reset the pc back to its 281 * original value and turn off the flags. 282 */ 283 if (rp->r_pc < t->t_dtrace_scrpc || 284 rp->r_pc > t->t_dtrace_astpc + isz) { 285 t->t_dtrace_ft = 0; 286 } else if (rp->r_pc == t->t_dtrace_scrpc || 287 rp->r_pc == t->t_dtrace_astpc) { 288 rp->r_pc = t->t_dtrace_pc; 289 t->t_dtrace_ft = 0; 290 } 291} 292 293int 294dtrace_safe_defer_signal(void) 295{ 296 kthread_t *t = curthread; 297 struct regs *rp = lwptoregs(ttolwp(t)); 298 size_t isz = t->t_dtrace_npc - t->t_dtrace_pc; 299 300 ASSERT(t->t_dtrace_on); 301 302 /* 303 * If we're not in the range of scratch addresses, we're not actually 304 * tracing user instructions so turn off the flags. 305 */ 306 if (rp->r_pc < t->t_dtrace_scrpc || 307 rp->r_pc > t->t_dtrace_astpc + isz) { 308 t->t_dtrace_ft = 0; 309 return (0); 310 } 311 312 /* 313 * If we've executed the original instruction, but haven't performed 314 * the jmp back to t->t_dtrace_npc or the clean up of any registers 315 * used to emulate %rip-relative instructions in 64-bit mode, do that 316 * here and take the signal right away. We detect this condition by 317 * seeing if the program counter is the range [scrpc + isz, astpc). 318 */ 319 if (t->t_dtrace_astpc - rp->r_pc < 320 t->t_dtrace_astpc - t->t_dtrace_scrpc - isz) { 321#ifdef __amd64 322 /* 323 * If there is a scratch register and we're on the 324 * instruction immediately after the modified instruction, 325 * restore the value of that scratch register. 326 */ 327 if (t->t_dtrace_reg != 0 && 328 rp->r_pc == t->t_dtrace_scrpc + isz) { 329 switch (t->t_dtrace_reg) { 330 case REG_RAX: 331 rp->r_rax = t->t_dtrace_regv; 332 break; 333 case REG_RCX: 334 rp->r_rcx = t->t_dtrace_regv; 335 break; 336 case REG_R8: 337 rp->r_r8 = t->t_dtrace_regv; 338 break; 339 case REG_R9: 340 rp->r_r9 = t->t_dtrace_regv; 341 break; 342 } 343 } 344#endif 345 rp->r_pc = t->t_dtrace_npc; 346 t->t_dtrace_ft = 0; 347 return (0); 348 } 349 350 /* 351 * Otherwise, make sure we'll return to the kernel after executing 352 * the copied out instruction and defer the signal. 353 */ 354 if (!t->t_dtrace_step) { 355 ASSERT(rp->r_pc < t->t_dtrace_astpc); 356 rp->r_pc += t->t_dtrace_astpc - t->t_dtrace_scrpc; 357 t->t_dtrace_step = 1; 358 } 359 360 t->t_dtrace_ast = 1; 361 362 return (1); 363} 364#endif 365 366static int64_t tgt_cpu_tsc; 367static int64_t hst_cpu_tsc; 368static int64_t tsc_skew[MAXCPU];
| 23 * 24 */ 25/* 26 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 27 * Use is subject to license terms. 28 */ 29 30#include <sys/param.h> 31#include <sys/systm.h> 32#include <sys/types.h> 33#include <sys/kernel.h> 34#include <sys/malloc.h> 35#include <sys/kmem.h> 36#include <sys/smp.h> 37#include <sys/dtrace_impl.h> 38#include <sys/dtrace_bsd.h> 39#include <machine/clock.h> 40#include <machine/frame.h> 41#include <vm/pmap.h> 42 43extern uintptr_t dtrace_in_probe_addr; 44extern int dtrace_in_probe; 45 46int dtrace_invop(uintptr_t, uintptr_t *, uintptr_t); 47 48typedef struct dtrace_invop_hdlr { 49 int (*dtih_func)(uintptr_t, uintptr_t *, uintptr_t); 50 struct dtrace_invop_hdlr *dtih_next; 51} dtrace_invop_hdlr_t; 52 53dtrace_invop_hdlr_t *dtrace_invop_hdlr; 54 55int 56dtrace_invop(uintptr_t addr, uintptr_t *stack, uintptr_t eax) 57{ 58 dtrace_invop_hdlr_t *hdlr; 59 int rval; 60 61 for (hdlr = dtrace_invop_hdlr; hdlr != NULL; hdlr = hdlr->dtih_next) 62 if ((rval = hdlr->dtih_func(addr, stack, eax)) != 0) 63 return (rval); 64 65 return (0); 66} 67 68void 69dtrace_invop_add(int (*func)(uintptr_t, uintptr_t *, uintptr_t)) 70{ 71 dtrace_invop_hdlr_t *hdlr; 72 73 hdlr = kmem_alloc(sizeof (dtrace_invop_hdlr_t), KM_SLEEP); 74 hdlr->dtih_func = func; 75 hdlr->dtih_next = dtrace_invop_hdlr; 76 dtrace_invop_hdlr = hdlr; 77} 78 79void 80dtrace_invop_remove(int (*func)(uintptr_t, uintptr_t *, uintptr_t)) 81{ 82 dtrace_invop_hdlr_t *hdlr = dtrace_invop_hdlr, *prev = NULL; 83 84 for (;;) { 85 if (hdlr == NULL) 86 panic("attempt to remove non-existent invop handler"); 87 88 if (hdlr->dtih_func == func) 89 break; 90 91 prev = hdlr; 92 hdlr = hdlr->dtih_next; 93 } 94 95 if (prev == NULL) { 96 ASSERT(dtrace_invop_hdlr == hdlr); 97 dtrace_invop_hdlr = hdlr->dtih_next; 98 } else { 99 ASSERT(dtrace_invop_hdlr != hdlr); 100 prev->dtih_next = hdlr->dtih_next; 101 } 102 103 kmem_free(hdlr, 0); 104} 105 106/*ARGSUSED*/ 107void 108dtrace_toxic_ranges(void (*func)(uintptr_t base, uintptr_t limit)) 109{ 110 (*func)(0, (uintptr_t) addr_PTmap); 111} 112 113void 114dtrace_xcall(processorid_t cpu, dtrace_xcall_t func, void *arg) 115{ 116 cpumask_t cpus; 117 118 critical_enter(); 119 120 if (cpu == DTRACE_CPUALL) 121 cpus = all_cpus; 122 else 123 cpus = (cpumask_t) (1 << cpu); 124 125 /* If the current CPU is in the set, call the function directly: */ 126 if ((cpus & (1 << curcpu)) != 0) { 127 (*func)(arg); 128 129 /* Mask the current CPU from the set */ 130 cpus &= ~(1 << curcpu); 131 } 132 133 /* If there are any CPUs in the set, cross-call to those CPUs */ 134 if (cpus != 0) 135 smp_rendezvous_cpus(cpus, NULL, func, smp_no_rendevous_barrier, arg); 136 137 critical_exit(); 138} 139 140static void 141dtrace_sync_func(void) 142{ 143} 144 145void 146dtrace_sync(void) 147{ 148 dtrace_xcall(DTRACE_CPUALL, (dtrace_xcall_t)dtrace_sync_func, NULL); 149} 150 151#ifdef notyet 152int (*dtrace_fasttrap_probe_ptr)(struct regs *); 153int (*dtrace_pid_probe_ptr)(struct regs *); 154int (*dtrace_return_probe_ptr)(struct regs *); 155 156void 157dtrace_user_probe(struct regs *rp, caddr_t addr, processorid_t cpuid) 158{ 159 krwlock_t *rwp; 160 proc_t *p = curproc; 161 extern void trap(struct regs *, caddr_t, processorid_t); 162 163 if (USERMODE(rp->r_cs) || (rp->r_ps & PS_VM)) { 164 if (curthread->t_cred != p->p_cred) { 165 cred_t *oldcred = curthread->t_cred; 166 /* 167 * DTrace accesses t_cred in probe context. t_cred 168 * must always be either NULL, or point to a valid, 169 * allocated cred structure. 170 */ 171 curthread->t_cred = crgetcred(); 172 crfree(oldcred); 173 } 174 } 175 176 if (rp->r_trapno == T_DTRACE_RET) { 177 uint8_t step = curthread->t_dtrace_step; 178 uint8_t ret = curthread->t_dtrace_ret; 179 uintptr_t npc = curthread->t_dtrace_npc; 180 181 if (curthread->t_dtrace_ast) { 182 aston(curthread); 183 curthread->t_sig_check = 1; 184 } 185 186 /* 187 * Clear all user tracing flags. 188 */ 189 curthread->t_dtrace_ft = 0; 190 191 /* 192 * If we weren't expecting to take a return probe trap, kill 193 * the process as though it had just executed an unassigned 194 * trap instruction. 195 */ 196 if (step == 0) { 197 tsignal(curthread, SIGILL); 198 return; 199 } 200 201 /* 202 * If we hit this trap unrelated to a return probe, we're 203 * just here to reset the AST flag since we deferred a signal 204 * until after we logically single-stepped the instruction we 205 * copied out. 206 */ 207 if (ret == 0) { 208 rp->r_pc = npc; 209 return; 210 } 211 212 /* 213 * We need to wait until after we've called the 214 * dtrace_return_probe_ptr function pointer to set %pc. 215 */ 216 rwp = &CPU->cpu_ft_lock; 217 rw_enter(rwp, RW_READER); 218 if (dtrace_return_probe_ptr != NULL) 219 (void) (*dtrace_return_probe_ptr)(rp); 220 rw_exit(rwp); 221 rp->r_pc = npc; 222 223 } else if (rp->r_trapno == T_DTRACE_PROBE) { 224 rwp = &CPU->cpu_ft_lock; 225 rw_enter(rwp, RW_READER); 226 if (dtrace_fasttrap_probe_ptr != NULL) 227 (void) (*dtrace_fasttrap_probe_ptr)(rp); 228 rw_exit(rwp); 229 230 } else if (rp->r_trapno == T_BPTFLT) { 231 uint8_t instr; 232 rwp = &CPU->cpu_ft_lock; 233 234 /* 235 * The DTrace fasttrap provider uses the breakpoint trap 236 * (int 3). We let DTrace take the first crack at handling 237 * this trap; if it's not a probe that DTrace knowns about, 238 * we call into the trap() routine to handle it like a 239 * breakpoint placed by a conventional debugger. 240 */ 241 rw_enter(rwp, RW_READER); 242 if (dtrace_pid_probe_ptr != NULL && 243 (*dtrace_pid_probe_ptr)(rp) == 0) { 244 rw_exit(rwp); 245 return; 246 } 247 rw_exit(rwp); 248 249 /* 250 * If the instruction that caused the breakpoint trap doesn't 251 * look like an int 3 anymore, it may be that this tracepoint 252 * was removed just after the user thread executed it. In 253 * that case, return to user land to retry the instuction. 254 */ 255 if (fuword8((void *)(rp->r_pc - 1), &instr) == 0 && 256 instr != FASTTRAP_INSTR) { 257 rp->r_pc--; 258 return; 259 } 260 261 trap(rp, addr, cpuid); 262 263 } else { 264 trap(rp, addr, cpuid); 265 } 266} 267 268void 269dtrace_safe_synchronous_signal(void) 270{ 271 kthread_t *t = curthread; 272 struct regs *rp = lwptoregs(ttolwp(t)); 273 size_t isz = t->t_dtrace_npc - t->t_dtrace_pc; 274 275 ASSERT(t->t_dtrace_on); 276 277 /* 278 * If we're not in the range of scratch addresses, we're not actually 279 * tracing user instructions so turn off the flags. If the instruction 280 * we copied out caused a synchonous trap, reset the pc back to its 281 * original value and turn off the flags. 282 */ 283 if (rp->r_pc < t->t_dtrace_scrpc || 284 rp->r_pc > t->t_dtrace_astpc + isz) { 285 t->t_dtrace_ft = 0; 286 } else if (rp->r_pc == t->t_dtrace_scrpc || 287 rp->r_pc == t->t_dtrace_astpc) { 288 rp->r_pc = t->t_dtrace_pc; 289 t->t_dtrace_ft = 0; 290 } 291} 292 293int 294dtrace_safe_defer_signal(void) 295{ 296 kthread_t *t = curthread; 297 struct regs *rp = lwptoregs(ttolwp(t)); 298 size_t isz = t->t_dtrace_npc - t->t_dtrace_pc; 299 300 ASSERT(t->t_dtrace_on); 301 302 /* 303 * If we're not in the range of scratch addresses, we're not actually 304 * tracing user instructions so turn off the flags. 305 */ 306 if (rp->r_pc < t->t_dtrace_scrpc || 307 rp->r_pc > t->t_dtrace_astpc + isz) { 308 t->t_dtrace_ft = 0; 309 return (0); 310 } 311 312 /* 313 * If we've executed the original instruction, but haven't performed 314 * the jmp back to t->t_dtrace_npc or the clean up of any registers 315 * used to emulate %rip-relative instructions in 64-bit mode, do that 316 * here and take the signal right away. We detect this condition by 317 * seeing if the program counter is the range [scrpc + isz, astpc). 318 */ 319 if (t->t_dtrace_astpc - rp->r_pc < 320 t->t_dtrace_astpc - t->t_dtrace_scrpc - isz) { 321#ifdef __amd64 322 /* 323 * If there is a scratch register and we're on the 324 * instruction immediately after the modified instruction, 325 * restore the value of that scratch register. 326 */ 327 if (t->t_dtrace_reg != 0 && 328 rp->r_pc == t->t_dtrace_scrpc + isz) { 329 switch (t->t_dtrace_reg) { 330 case REG_RAX: 331 rp->r_rax = t->t_dtrace_regv; 332 break; 333 case REG_RCX: 334 rp->r_rcx = t->t_dtrace_regv; 335 break; 336 case REG_R8: 337 rp->r_r8 = t->t_dtrace_regv; 338 break; 339 case REG_R9: 340 rp->r_r9 = t->t_dtrace_regv; 341 break; 342 } 343 } 344#endif 345 rp->r_pc = t->t_dtrace_npc; 346 t->t_dtrace_ft = 0; 347 return (0); 348 } 349 350 /* 351 * Otherwise, make sure we'll return to the kernel after executing 352 * the copied out instruction and defer the signal. 353 */ 354 if (!t->t_dtrace_step) { 355 ASSERT(rp->r_pc < t->t_dtrace_astpc); 356 rp->r_pc += t->t_dtrace_astpc - t->t_dtrace_scrpc; 357 t->t_dtrace_step = 1; 358 } 359 360 t->t_dtrace_ast = 1; 361 362 return (1); 363} 364#endif 365 366static int64_t tgt_cpu_tsc; 367static int64_t hst_cpu_tsc; 368static int64_t tsc_skew[MAXCPU];
|
416 continue; 417 418 map = 0; 419 map |= (1 << curcpu); 420 map |= (1 << i); 421 422 smp_rendezvous_cpus(map, dtrace_gethrtime_init_sync, 423 dtrace_gethrtime_init_cpu, 424 smp_no_rendevous_barrier, (void *)(uintptr_t) i); 425 426 tsc_skew[i] = tgt_cpu_tsc - hst_cpu_tsc; 427 } 428} 429 430SYSINIT(dtrace_gethrtime_init, SI_SUB_SMP, SI_ORDER_ANY, dtrace_gethrtime_init, NULL); 431 432/* 433 * DTrace needs a high resolution time function which can 434 * be called from a probe context and guaranteed not to have 435 * instrumented with probes itself. 436 * 437 * Returns nanoseconds since boot. 438 */ 439uint64_t 440dtrace_gethrtime() 441{
| 447 continue; 448 449 map = 0; 450 map |= (1 << curcpu); 451 map |= (1 << i); 452 453 smp_rendezvous_cpus(map, dtrace_gethrtime_init_sync, 454 dtrace_gethrtime_init_cpu, 455 smp_no_rendevous_barrier, (void *)(uintptr_t) i); 456 457 tsc_skew[i] = tgt_cpu_tsc - hst_cpu_tsc; 458 } 459} 460 461SYSINIT(dtrace_gethrtime_init, SI_SUB_SMP, SI_ORDER_ANY, dtrace_gethrtime_init, NULL); 462 463/* 464 * DTrace needs a high resolution time function which can 465 * be called from a probe context and guaranteed not to have 466 * instrumented with probes itself. 467 * 468 * Returns nanoseconds since boot. 469 */ 470uint64_t 471dtrace_gethrtime() 472{
|