Date: Sun, 30 Dec 2007 02:23:05 GMT From: John Birrell <jb@FreeBSD.org> To: Perforce Change Reviews <perforce@freebsd.org> Subject: PERFORCE change 132008 for review Message-ID: <200712300223.lBU2N5T0065985@repoman.freebsd.org>
next in thread | raw e-mail | index | archive | help
http://perforce.freebsd.org/chv.cgi?CH=132008 Change 132008 by jb@jb_freebsd1 on 2007/12/30 02:22:37 Work in progress. Affected files ... .. //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_anon.c#6 edit .. //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_cddl.h#3 edit .. //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_ioctl.c#16 edit .. //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_load.c#16 edit .. //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_unload.c#14 edit .. //depot/projects/dtrace/src/sys/contrib/opensolaris/uts/common/dtrace/dtrace.c#4 edit Differences ... ==== //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_anon.c#6 (text+ko) ==== @@ -59,128 +59,3 @@ (void) dtrace_state_go(state, &dtrace_anon.dta_beganon); } } - -static dtrace_state_t * -dtrace_anon_grab(void) -{ - dtrace_state_t *state; - - ASSERT(MUTEX_HELD(&dtrace_lock)); - - if ((state = dtrace_anon.dta_state) == NULL) { - ASSERT(dtrace_anon.dta_enabling == NULL); - return (NULL); - } - - ASSERT(dtrace_anon.dta_enabling != NULL); - ASSERT(dtrace_retained != NULL); - - dtrace_enabling_destroy(dtrace_anon.dta_enabling); - dtrace_anon.dta_enabling = NULL; - dtrace_anon.dta_state = NULL; - - return (state); -} - -static void -dtrace_anon_property(void) -{ - int i, rv; - dtrace_state_t *state; - dof_hdr_t *dof; - char c[32]; /* enough for "dof-data-" + digits */ - - ASSERT(MUTEX_HELD(&dtrace_lock)); - ASSERT(MUTEX_HELD(&cpu_lock)); - - for (i = 0; ; i++) { - (void) snprintf(c, sizeof (c), "dof-data-%d", i); - - dtrace_err_verbose = 1; - - if ((dof = dtrace_dof_property(c)) == NULL) { - dtrace_err_verbose = 0; - break; - } - - /* - * We want to create anonymous state, so we need to transition - * the kernel debugger to indicate that DTrace is active. If - * this fails (e.g. because the debugger has modified text in - * some way), we won't continue with the processing. - */ - if (kdi_dtrace_set(KDI_DTSET_DTRACE_ACTIVATE) != 0) { - cmn_err(CE_NOTE, "kernel debugger active; anonymous " - "enabling ignored."); - dtrace_dof_destroy(dof); - break; - } - - /* - * If we haven't allocated an anonymous state, we'll do so now. - */ - if ((state = dtrace_anon.dta_state) == NULL) { -#if defined(sun) - state = dtrace_state_create(NULL, NULL); -#else - state = dtrace_state_create(NULL); -#endif - dtrace_anon.dta_state = state; - - if (state == NULL) { - /* - * This basically shouldn't happen: the only - * failure mode from dtrace_state_create() is a - * failure of ddi_soft_state_zalloc() that - * itself should never happen. Still, the - * interface allows for a failure mode, and - * we want to fail as gracefully as possible: - * we'll emit an error message and cease - * processing anonymous state in this case. - */ - cmn_err(CE_WARN, "failed to create " - "anonymous state"); - dtrace_dof_destroy(dof); - break; - } - } - - rv = dtrace_dof_slurp(dof, &state->dts_vstate, CRED(), - &dtrace_anon.dta_enabling, 0, B_TRUE); - - if (rv == 0) - rv = dtrace_dof_options(dof, state); - - dtrace_err_verbose = 0; - dtrace_dof_destroy(dof); - - if (rv != 0) { - /* - * This is malformed DOF; chuck any anonymous state - * that we created. - */ - ASSERT(dtrace_anon.dta_enabling == NULL); - dtrace_state_destroy(state); - dtrace_anon.dta_state = NULL; - break; - } - - ASSERT(dtrace_anon.dta_enabling != NULL); - } - - if (dtrace_anon.dta_enabling != NULL) { - int rval; - - /* - * dtrace_enabling_retain() can only fail because we are - * trying to retain more enablings than are allowed -- but - * we only have one anonymous enabling, and we are guaranteed - * to be allowed at least one retained enabling; we assert - * that dtrace_enabling_retain() returns success. - */ - rval = dtrace_enabling_retain(dtrace_anon.dta_enabling); - ASSERT(rval == 0); - - dtrace_enabling_dump(dtrace_anon.dta_enabling); - } -} ==== //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_cddl.h#3 (text+ko) ==== @@ -27,6 +27,8 @@ #include <sys/proc.h> +#define LOCK_LEVEL 10 + /* * Kernel DTrace extension to 'struct proc' for FreeBSD. */ @@ -93,11 +95,40 @@ * Definitions for fields in struct proc which are named differntly in FreeBSD. */ #define p_cred p_ucred +#define p_parent p_pptr /* * Definitions for fields in struct thread which are named differntly in FreeBSD. */ #define t_procp td_proc #define t_tid td_tid +#define t_did td_tid + + +int priv_policy(const cred_t *, int, boolean_t, int, const char *); +boolean_t priv_policy_only(const cred_t *, int, boolean_t); +boolean_t priv_policy_choice(const cred_t *, int, boolean_t); + +/* + * Test privilege. Audit success or failure, allow privilege debugging. + * Returns 0 for success, err for failure. + */ +#define PRIV_POLICY(cred, priv, all, err, reason) \ + priv_policy((cred), (priv), (all), (err), (reason)) + +/* + * Test privilege. Audit success only, no privilege debugging. + * Returns 1 for success, and 0 for failure. + */ +#define PRIV_POLICY_CHOICE(cred, priv, all) \ + priv_policy_choice((cred), (priv), (all)) + +/* + * Test privilege. No priv_debugging, no auditing. + * Returns 1 for success, and 0 for failure. + */ + +#define PRIV_POLICY_ONLY(cred, priv, all) \ + priv_policy_only((cred), (priv), (all)) #endif /* !_DTRACE_CDDL_H_ */ ==== //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_ioctl.c#16 (text+ko) ==== @@ -336,7 +336,7 @@ } if ((dof = dtrace_dof_copyin((uintptr_t) p->dof, &rval)) == NULL) - return (rval); + return (EINVAL); mutex_enter(&cpu_lock); mutex_enter(&dtrace_lock); @@ -738,10 +738,6 @@ return (rval); } - /* Really handled in upper layer */ - case FIOASYNC: - case FIONBIO: - break; default: error = ENOTTY; } ==== //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_load.c#16 (text+ko) ==== @@ -39,8 +39,7 @@ * XXX This is a short term hack to avoid having to comment * out lots and lots of lock/unlock calls. */ - dtrace_mutex_init(&cpu_lock,"XXX cpu_lock hack"); - dtrace_mutex_init(&mod_lock,"XXX mod_lock hack"); + mutex_init(&mod_lock,"XXX mod_lock hack", MUTEX_DEFAULT, NULL); /* * Initialise the mutexes without 'witness' because the dtrace @@ -50,10 +49,10 @@ * low memory situation. And that low memory situation might be * the very problem we are trying to trace. */ - dtrace_mutex_init(&dtrace_lock,"dtrace probe state"); - dtrace_mutex_init(&dtrace_provider_lock,"dtrace provider state"); - dtrace_mutex_init(&dtrace_meta_lock,"dtrace meta-provider state"); - dtrace_mutex_init(&dtrace_errlock,"dtrace error lock"); + mutex_init(&dtrace_lock,"dtrace probe state", MUTEX_DEFAULT, NULL); + mutex_init(&dtrace_provider_lock,"dtrace provider state", MUTEX_DEFAULT, NULL); + mutex_init(&dtrace_meta_lock,"dtrace meta-provider state", MUTEX_DEFAULT, NULL); + mutex_init(&dtrace_errlock,"dtrace error lock", MUTEX_DEFAULT, NULL); mutex_enter(&cpu_lock); mutex_enter(&dtrace_provider_lock); ==== //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_unload.c#14 (text+ko) ==== @@ -61,11 +61,13 @@ ASSERT(state->dts_necbs == 0); dtrace_state_destroy(state); +#ifdef DOODAD /* * If we're being detached with anonymous state, we need to * indicate to the kernel debugger that DTrace is now inactive. */ (void) kdi_dtrace_set(KDI_DTSET_DTRACE_DEACTIVATE); +#endif } bzero(&dtrace_anon, sizeof (dtrace_anon_t)); @@ -145,14 +147,13 @@ dtrace_taskq = NULL; #endif - dtrace_mutex_destroy(&dtrace_meta_lock); - dtrace_mutex_destroy(&dtrace_provider_lock); - dtrace_mutex_destroy(&dtrace_lock); - dtrace_mutex_destroy(&dtrace_errlock); + mutex_destroy(&dtrace_meta_lock); + mutex_destroy(&dtrace_provider_lock); + mutex_destroy(&dtrace_lock); + mutex_destroy(&dtrace_errlock); /* XXX Hack */ - dtrace_mutex_destroy(&cpu_lock); - dtrace_mutex_destroy(&mod_lock); + mutex_destroy(&mod_lock); /* * Reset our hook for thread switches, but ensure that vtime isn't ==== //depot/projects/dtrace/src/sys/contrib/opensolaris/uts/common/dtrace/dtrace.c#4 (text) ==== @@ -114,7 +114,9 @@ #include <sys/limits.h> #include <sys/kernel.h> #include <sys/malloc.h> +#include <sys/sysctl.h> #include <sys/vmem.h> +#include <sys/dtrace_bsd.h> #include "dtrace_cddl.h" #endif @@ -190,14 +192,18 @@ #endif static vmem_t *dtrace_arena; /* probe ID arena */ static vmem_t *dtrace_minor; /* minor number arena */ +#if defined(sun) static taskq_t *dtrace_taskq; /* task queue */ +#endif static dtrace_probe_t **dtrace_probes; /* array of all probes */ static int dtrace_nprobes; /* number of probes */ static dtrace_provider_t *dtrace_provider; /* provider list */ static dtrace_meta_t *dtrace_meta_pid; /* user-land meta provider */ static int dtrace_opens; /* number of opens */ static int dtrace_helpers; /* number of helpers */ +#if defined(sun) static void *dtrace_softstate; /* softstate pointer */ +#endif static dtrace_hash_t *dtrace_bymod; /* probes hashed by module */ static dtrace_hash_t *dtrace_byfunc; /* probes hashed by function */ static dtrace_hash_t *dtrace_byname; /* probes hashed by name */ @@ -252,7 +258,6 @@ MALLOC_DEFINE(M_DTRACE, "dtrace", "Dynamic Trace"); /* XXX FreeBSD hacks. */ -static kmutex_t cpu_lock; static kmutex_t mod_lock; #define cr_suid cr_svuid @@ -387,6 +392,7 @@ * no way for a global variable key signature to match a thread-local key * signature. */ +#if defined(sun) #define DTRACE_TLS_THRKEY(where) { \ uint_t intr = 0; \ uint_t actv = CPU->cpu_intr_actv >> (LOCK_LEVEL + 1); \ @@ -396,6 +402,18 @@ (where) = ((curthread->t_did + DIF_VARIABLE_MAX) & \ (((uint64_t)1 << 61) - 1)) | ((uint64_t)intr << 61); \ } +#else +#define DTRACE_TLS_THRKEY(where) { \ + solaris_cpu_t *_c = &solaris_cpu[curcpu]; \ + uint_t intr = 0; \ + uint_t actv = _c->cpu_intr_actv >> (LOCK_LEVEL + 1); \ + for (; actv; actv >>= 1) \ + intr++; \ + ASSERT(intr < (1 << 3)); \ + (where) = ((curthread->td_tid + DIF_VARIABLE_MAX) & \ + (((uint64_t)1 << 61) - 1)) | ((uint64_t)intr << 61); \ +} +#endif #define DT_BSWAP_8(x) ((x) & 0xff) #define DT_BSWAP_16(x) ((DT_BSWAP_8(x) << 8) | DT_BSWAP_8((x) >> 8)) @@ -463,7 +481,7 @@ * This address falls within a toxic region; return 0. \ */ \ *flags |= CPU_DTRACE_BADADDR; \ - cpu_core[curcpu].cpuc_dtrace_illval = addr; \ + cpu_core[curcpu].cpuc_dtrace_illval = addr; \ return (0); \ } \ \ @@ -513,16 +531,20 @@ static int dtrace_enabling_match(dtrace_enabling_t *, int *); static void dtrace_enabling_matchall(void); static dtrace_state_t *dtrace_anon_grab(void); +#if defined(sun) static uint64_t dtrace_helper(int, dtrace_mstate_t *, dtrace_state_t *, uint64_t, uint64_t); static dtrace_helpers_t *dtrace_helpers_create(proc_t *); +#endif static void dtrace_buffer_drop(dtrace_buffer_t *); static intptr_t dtrace_buffer_reserve(dtrace_buffer_t *, size_t, size_t, dtrace_state_t *, dtrace_mstate_t *); static int dtrace_state_option(dtrace_state_t *, dtrace_optid_t, dtrace_optval_t); static int dtrace_ecb_create_enable(dtrace_probe_t *, void *); +#if defined(sun) static void dtrace_helper_provider_destroy(dtrace_helper_provider_t *); +#endif uint16_t dtrace_load16(uintptr_t); uint32_t dtrace_load32(uintptr_t); uint64_t dtrace_load64(uintptr_t); @@ -2124,7 +2146,7 @@ dtrace_speculation_t *spec; dtrace_buffer_t *src, *dest; uintptr_t daddr, saddr, dlimit; - dtrace_speculation_state_t current, new; + dtrace_speculation_state_t current, new = 0; intptr_t offs; if (which == 0) @@ -2260,7 +2282,7 @@ dtrace_specid_t which) { dtrace_speculation_t *spec; - dtrace_speculation_state_t current, new; + dtrace_speculation_state_t current, new = 0; dtrace_buffer_t *buf; if (which == 0) @@ -2422,7 +2444,7 @@ dtrace_specid_t which) { dtrace_speculation_t *spec; - dtrace_speculation_state_t current, new; + dtrace_speculation_state_t current, new = 0; dtrace_buffer_t *buf; if (which == 0) @@ -2794,19 +2816,22 @@ */ return ((uint64_t)curthread->t_procp->p_ppid); #else - return ((uint64_t)curproc->p_ppid); + return ((uint64_t)curproc->p_pptr->p_pid); #endif case DIF_VAR_TID: +#if defined(sun) /* * See comment in DIF_VAR_PID. */ if (DTRACE_ANCHORED(mstate->dtms_probe) && CPU_ON_INTR(CPU)) return (0); +#endif return ((uint64_t)curthread->t_tid); case DIF_VAR_EXECNAME: +#if defined(sun) if (!dtrace_priv_proc(state)) return (0); @@ -2825,6 +2850,9 @@ return (dtrace_dif_varstr( (uintptr_t)curthread->t_procp->p_user.u_comm, state, mstate)); +#else + return ((uint64_t)(uintptr_t) curthread->td_proc->p_comm); +#endif case DIF_VAR_ZONENAME: #if defined(sun) @@ -2854,11 +2882,13 @@ if (!dtrace_priv_proc(state)) return (0); +#if defined(sun) /* * See comment in DIF_VAR_PID. */ if (DTRACE_ANCHORED(mstate->dtms_probe) && CPU_ON_INTR(CPU)) return ((uint64_t)p0.p_cred->cr_uid); +#endif /* * It is always safe to dereference one's own t_procp pointer: @@ -2875,11 +2905,13 @@ if (!dtrace_priv_proc(state)) return (0); +#if defined(sun) /* * See comment in DIF_VAR_PID. */ if (DTRACE_ANCHORED(mstate->dtms_probe) && CPU_ON_INTR(CPU)) return ((uint64_t)p0.p_cred->cr_gid); +#endif /* * It is always safe to dereference one's own t_procp pointer: @@ -2893,6 +2925,7 @@ return ((uint64_t)curthread->t_procp->p_cred->cr_gid); case DIF_VAR_ERRNO: { +#if defined(sun) klwp_t *lwp; if (!dtrace_priv_proc(state)) return (0); @@ -2913,6 +2946,9 @@ return (0); return ((uint64_t)lwp->lwp_errno); +#else + return (0); +#endif } default: DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP); @@ -2936,6 +2972,7 @@ volatile uintptr_t *illval = &cpu_core[curcpu].cpuc_dtrace_illval; dtrace_vstate_t *vstate = &state->dts_vstate; +#ifdef DOODAD union { mutex_impl_t mi; uint64_t mx; @@ -2945,6 +2982,7 @@ krwlock_t ri; uintptr_t rw; } r; +#endif switch (subr) { case DIF_SUBR_RAND: @@ -2952,6 +2990,8 @@ break; case DIF_SUBR_MUTEX_OWNED: +#ifdef DOODAD + union { if (!dtrace_canload(tupregs[0].dttk_value, sizeof (kmutex_t), mstate, vstate)) { regs[rd] = 0; @@ -2963,9 +3003,12 @@ regs[rd] = MUTEX_OWNER(&m.mi) != MUTEX_NO_OWNER; else regs[rd] = LOCK_HELD(&m.mi.m_spin.m_spinlock); +#endif break; case DIF_SUBR_MUTEX_OWNER: +#ifdef DOODAD + union { if (!dtrace_canload(tupregs[0].dttk_value, sizeof (kmutex_t), mstate, vstate)) { regs[rd] = 0; @@ -2978,9 +3021,12 @@ regs[rd] = (uintptr_t)MUTEX_OWNER(&m.mi); else regs[rd] = 0; +#endif break; case DIF_SUBR_MUTEX_TYPE_ADAPTIVE: +#ifdef DOODAD + union { if (!dtrace_canload(tupregs[0].dttk_value, sizeof (kmutex_t), mstate, vstate)) { regs[rd] = 0; @@ -2989,9 +3035,12 @@ m.mx = dtrace_load64(tupregs[0].dttk_value); regs[rd] = MUTEX_TYPE_ADAPTIVE(&m.mi); +#endif break; case DIF_SUBR_MUTEX_TYPE_SPIN: +#ifdef DOODAD + union { if (!dtrace_canload(tupregs[0].dttk_value, sizeof (kmutex_t), mstate, vstate)) { regs[rd] = 0; @@ -3000,9 +3049,12 @@ m.mx = dtrace_load64(tupregs[0].dttk_value); regs[rd] = MUTEX_TYPE_SPIN(&m.mi); +#endif break; case DIF_SUBR_RW_READ_HELD: { +#ifdef DOODAD + union { uintptr_t tmp; if (!dtrace_canload(tupregs[0].dttk_value, sizeof (uintptr_t), @@ -3013,10 +3065,13 @@ r.rw = dtrace_loadptr(tupregs[0].dttk_value); regs[rd] = _RW_READ_HELD(&r.ri, tmp); +#endif break; } case DIF_SUBR_RW_WRITE_HELD: +#ifdef DOODAD + union { if (!dtrace_canload(tupregs[0].dttk_value, sizeof (krwlock_t), mstate, vstate)) { regs[rd] = 0; @@ -3025,9 +3080,12 @@ r.rw = dtrace_loadptr(tupregs[0].dttk_value); regs[rd] = _RW_WRITE_HELD(&r.ri); +#endif break; case DIF_SUBR_RW_ISWRITER: +#ifdef DOODAD + union { if (!dtrace_canload(tupregs[0].dttk_value, sizeof (krwlock_t), mstate, vstate)) { regs[rd] = 0; @@ -3036,6 +3094,7 @@ r.rw = dtrace_loadptr(tupregs[0].dttk_value); regs[rd] = _RW_ISWRITER(&r.ri); +#endif break; case DIF_SUBR_BCOPY: { @@ -3469,7 +3528,7 @@ uintptr_t tokaddr = tupregs[1].dttk_value; uint64_t size = state->dts_options[DTRACEOPT_STRSIZE]; uintptr_t limit, toklimit = tokaddr + size; - uint8_t c, tokmap[32]; /* 256 / 8 */ + uint8_t c = 0, tokmap[32]; /* 256 / 8 */ char *dest = (char *)mstate->dtms_scratch_ptr; int i; @@ -4421,7 +4480,7 @@ uint8_t cc_n = 0, cc_z = 0, cc_v = 0, cc_c = 0; int64_t cc_r; - uint_t pc = 0, id, opc; + uint_t pc = 0, id, opc = 0; uint8_t ttop = 0; dif_instr_t instr; uint_t r1, r2, rd; @@ -5296,8 +5355,8 @@ if (curthread->t_dtrace_sig == 0) curthread->t_dtrace_sig = (uint8_t)sig; +#ifdef DOODAD curthread->t_sig_check = 1; -#ifdef DOODAD aston(curthread); #endif } @@ -5310,8 +5369,8 @@ if (!curthread->t_dtrace_stop) { curthread->t_dtrace_stop = 1; +#ifdef DOODAD curthread->t_sig_check = 1; -#ifdef DOODAD aston(curthread); #endif } @@ -5320,12 +5379,14 @@ static void dtrace_action_chill(dtrace_mstate_t *mstate, hrtime_t val) { +#ifdef DOODAD hrtime_t now; volatile uint16_t *flags; #if defined(sun) cpu_t *cpu = CPU; #else - cpu_t *cpu = pcpu_find(curcpu); + cpu_t *c = &solaris_cpu[curcpu]; + struct pcpu *cpu = pcpu_find(curcpu); #endif if (dtrace_destructive_disallow) @@ -5364,6 +5425,7 @@ */ mstate->dtms_present &= ~DTRACE_MSTATE_TIMESTAMP; cpu->cpu_dtrace_chilled += val; +#endif } static void @@ -5502,6 +5564,7 @@ volatile uint16_t *flags; hrtime_t now; +#if defined(sun) /* * Kick out immediately if this CPU is still being born (in which case * curthread will be set to -1) or the current thread can't allow @@ -5509,6 +5572,7 @@ */ if (((uintptr_t)curthread & 1) || (curthread->t_flag & T_DONTDTRACE)) return; +#endif cookie = dtrace_interrupt_disable(); probe = dtrace_probes[id - 1]; @@ -5572,11 +5636,7 @@ * arguments to aggregating actions, one iteration of the * action loop will use the last iteration's value. */ -#ifdef lint uint64_t val = 0; -#else - uint64_t val; -#endif mstate.dtms_present = DTRACE_MSTATE_ARGS | DTRACE_MSTATE_PROBE; *flags &= ~CPU_DTRACE_ERROR; @@ -6382,6 +6442,7 @@ { uint32_t priv; +#if defined(sun) if (cr == NULL || PRIV_POLICY_ONLY(cr, PRIV_ALL, B_FALSE)) { /* * For DTRACE_PRIV_ALL, the uid and zoneid don't matter. @@ -6403,6 +6464,9 @@ if (PRIV_POLICY_ONLY(cr, PRIV_PROC_ZONE, B_FALSE)) priv |= DTRACE_PRIV_ZONEOWNER; } +#else + priv = DTRACE_PRIV_ALL; +#endif *privp = priv; } @@ -7446,6 +7510,7 @@ } while (all && (prv = prv->dtpv_next) != NULL); } +#if defined(sun) /* * Iterate over each probe, and call the Framework-to-Provider API function * denoted by offs. @@ -7486,6 +7551,7 @@ dtrace_interrupt_enable(cookie); } +#endif static int dtrace_probe_enable(dtrace_probedesc_t *desc, dtrace_enabling_t *enab) @@ -7657,6 +7723,7 @@ dtrace_enabling_matchall(); } +#if defined(sun) static void dtrace_helper_provider_remove_one(dof_helper_t *dhp, dof_sec_t *sec, pid_t pid) { @@ -7704,6 +7771,7 @@ dtrace_helper_provider_remove_one(dhp, sec, pid); } } +#endif /* * DTrace Meta Provider-to-Framework API Functions @@ -8243,6 +8311,7 @@ return (err); } +#if defined(sun) /* * Validate a DTrace DIF object that it is to be used as a helper. Helpers * are much more constrained than normal DIFOs. Specifically, they may @@ -8397,6 +8466,7 @@ return (err); } +#endif /* * Returns 1 if the expression in the DIF object can be cached on a per-thread @@ -8482,7 +8552,7 @@ static void dtrace_difo_chunksize(dtrace_difo_t *dp, dtrace_vstate_t *vstate) { - uint64_t sval; + uint64_t sval = 0; dtrace_key_t tupregs[DIF_DTR_NREGS + 2]; /* +2 for thread and id */ const dif_instr_t *text = dp->dtdo_buf; uint_t pc, srd = 0; @@ -8496,7 +8566,7 @@ uint_t rd = DIF_INSTR_RD(instr); uint_t r1 = DIF_INSTR_R1(instr); uint_t nkeys = 0; - uchar_t scope; + uchar_t scope = 0; dtrace_key_t *key = tupregs; @@ -8625,10 +8695,10 @@ for (i = 0; i < dp->dtdo_varlen; i++) { dtrace_difv_t *v = &dp->dtdo_vartab[i]; - dtrace_statvar_t *svar, ***svarp; + dtrace_statvar_t *svar, ***svarp = NULL; size_t dsize = 0; uint8_t scope = v->dtdv_scope; - int *np; + int *np = NULL; if ((id = v->dtdv_id) < DIF_VAR_OTHER_UBASE) continue; @@ -8727,6 +8797,7 @@ dtrace_difo_hold(dp); } +#if defined(sun) static dtrace_difo_t * dtrace_difo_duplicate(dtrace_difo_t *dp, dtrace_vstate_t *vstate) { @@ -8770,6 +8841,7 @@ dtrace_difo_init(new, vstate); return (new); } +#endif static void dtrace_difo_destroy(dtrace_difo_t *dp, dtrace_vstate_t *vstate) @@ -8780,10 +8852,10 @@ for (i = 0; i < dp->dtdo_varlen; i++) { dtrace_difv_t *v = &dp->dtdo_vartab[i]; - dtrace_statvar_t *svar, **svarp; + dtrace_statvar_t *svar, **svarp = NULL; uint_t id; uint8_t scope = v->dtdv_scope; - int *np; + int *np = NULL; switch (scope) { case DIFV_SCOPE_THREAD: @@ -9476,7 +9548,7 @@ uint16_t format = 0; dtrace_recdesc_t *rec; dtrace_state_t *state = ecb->dte_state; - dtrace_optval_t *opt = state->dts_options, nframes, strsize; + dtrace_optval_t *opt = state->dts_options, nframes = 0, strsize; uint64_t arg = desc->dtad_arg; ASSERT(MUTEX_HELD(&dtrace_lock)); @@ -10061,7 +10133,11 @@ dtrace_buffer_alloc(dtrace_buffer_t *bufs, size_t size, int flags, processorid_t cpu) { +#if defined(sun) cpu_t *cp; +#else + struct pcpu *cp; +#endif dtrace_buffer_t *buf; #if defined(sun) @@ -11116,6 +11192,41 @@ return (dof); } +#if !defined(sun) +static __inline uchar_t +dtrace_dof_char(char c) { + switch (c) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + return (c - '0'); + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + return (c - 'A' + 10); + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + return (c - 'a' + 10); + } + /* Should not reach here. */ + return (0); +} +#endif + static dof_hdr_t * dtrace_dof_property(const char *name) { @@ -11133,39 +11244,71 @@ if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dtrace_devi, 0, (char *)name, (int **)&buf, &len) != DDI_PROP_SUCCESS) return (NULL); -#endif for (i = 0; i < len; i++) buf[i] = (uchar_t)(((int *)buf)[i]); if (len < sizeof (dof_hdr_t)) { -#if defined(sun) ddi_prop_free(buf); -#endif dtrace_dof_error(NULL, "truncated header"); return (NULL); } if (len < (loadsz = ((dof_hdr_t *)buf)->dofh_loadsz)) { -#if defined(sun) ddi_prop_free(buf); -#endif dtrace_dof_error(NULL, "truncated DOF"); return (NULL); } if (loadsz >= dtrace_dof_maxsize) { -#if defined(sun) ddi_prop_free(buf); -#endif dtrace_dof_error(NULL, "oversized DOF"); return (NULL); } dof = kmem_alloc(loadsz, KM_SLEEP); bcopy(buf, dof, loadsz); -#if defined(sun) ddi_prop_free(buf); +#else + char *p; + char *p_env; + + if ((p_env = getenv(name)) == NULL) + return (NULL); + + len = strlen(p_env) / 2; + + buf = kmem_alloc(len, KM_SLEEP); + + dof = (dof_hdr_t *) buf; + + p = p_env; + + for (i = 0; i < len; i++) { + buf[i] = (dtrace_dof_char(p[0]) << 4) | + dtrace_dof_char(p[1]); + p += 2; + } + + freeenv(p_env); + + if (len < sizeof (dof_hdr_t)) { + free(buf, M_DTRACE); + dtrace_dof_error(NULL, "truncated header"); + return (NULL); + } + + if (len < (loadsz = dof->dofh_loadsz)) { + free(buf, M_DTRACE); + dtrace_dof_error(NULL, "truncated DOF"); + return (NULL); + } + + if (loadsz >= dtrace_dof_maxsize) { + free(buf, M_DTRACE); + dtrace_dof_error(NULL, "oversized DOF"); + return (NULL); + } #endif return (dof); @@ -11976,7 +12119,7 @@ /* * DTrace Consumer State Functions */ -int +static int dtrace_dstate_init(dtrace_dstate_t *dstate, size_t size) { size_t hashsize, maxper, min, chunksize = dstate->dtds_chunksize; @@ -12078,7 +12221,7 @@ return (0); } -void +static void dtrace_dstate_fini(dtrace_dstate_t *dstate) { ASSERT(MUTEX_HELD(&cpu_lock)); @@ -12153,7 +12296,7 @@ state->dts_alive = now; } -dtrace_state_t * +static dtrace_state_t * #if defined(sun) dtrace_state_create(dev_t *devp, cred_t *cr) #else @@ -12389,7 +12532,7 @@ dtrace_state_buffer(dtrace_state_t *state, dtrace_buffer_t *buf, int which) { dtrace_optval_t *opt = state->dts_options, size; - processorid_t cpu; + processorid_t cpu = 0;; int flags = 0, rval; ASSERT(MUTEX_HELD(&dtrace_lock)); @@ -13131,6 +13274,7 @@ } >>> TRUNCATED FOR MAIL (1000 lines) <<<
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200712300223.lBU2N5T0065985>