Changed from using mutex_is_locked() to a new mutex_owned(), in support of the

Solaris MUTEX_HELD() macro.  The former was merely testing whether the mutex was
locked, whereas the real test needed here is whether the mutex is held by the
current thread.

Signed-off-by: Kris Van Hees <kris.van.hees@oracle.com>

diff --git a/dtrace/dtrace.h b/dtrace/dtrace.h
index a55f7898187d16aefda950be76bf8010968ac105..b6847544489ab295b998a1fdf57b27b1997dc251 100644 (file)
--- a/dtrace/dtrace.h
+++ b/dtrace/dtrace.h
@@ -7,6 +7,7 @@
 #include <linux/idr.h>
 #include <linux/ktime.h>
 #include <linux/module.h>
+#include <linux/mutex.h>
 #include <linux/sched.h>
 #include <linux/stringify.h>
 #include <linux/types.h>
@@ -2363,4 +2364,6 @@ extern void debug_enter(char *);
                                } while (0)
 #endif
 
+#define MUTEX_HELD(lock)       mutex_owned(lock)
+
 #endif /* _DTRACE_H_ */

diff --git a/dtrace/dtrace_anon.c b/dtrace/dtrace_anon.c
index 70d43ac30b696804262a1275a5d4d85ac17e325f..e5d0996d45849920fb0eb1529c51fcde944bd3ec 100644 (file)
--- a/dtrace/dtrace_anon.c
+++ b/dtrace/dtrace_anon.c
@@ -33,7 +33,7 @@ dtrace_state_t *dtrace_anon_grab(void)
 {
        dtrace_state_t  *state;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
 
        if ((state = dtrace_anon.dta_state) == NULL) {
                ASSERT(dtrace_anon.dta_enabling == NULL);
@@ -58,8 +58,8 @@ void dtrace_anon_property(void)
        dof_hdr_t       *dof;
        char            c[32];             /* enough for "dof-data-" + digits */
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
-       ASSERT(mutex_is_locked(&cpu_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&cpu_lock));
 
        for (i = 0; ; i++) {
                snprintf(c, sizeof (c), "dof-data-%d", i);

diff --git a/dtrace/dtrace_buffer.c b/dtrace/dtrace_buffer.c
index 47080b1f888c0d136853a2a8630f3be13f74f4da..361cd687956acdd18d34e226fb7cd9f5f8d1ef30 100644 (file)
--- a/dtrace/dtrace_buffer.c
+++ b/dtrace/dtrace_buffer.c
@@ -97,8 +97,8 @@ int dtrace_buffer_alloc(dtrace_buffer_t *bufs, size_t size, int flags,
        processorid_t   cpu;
        dtrace_buffer_t *buf;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
-       ASSERT(mutex_is_locked(&cpu_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&cpu_lock));
 
 #ifdef FIXME
        if (size > dtrace_nonroot_maxsize &&
@@ -405,7 +405,7 @@ out:
 void dtrace_buffer_polish(dtrace_buffer_t *buf)
 {
        ASSERT(buf->dtb_flags & DTRACEBUF_RING);
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
 
        if (!(buf->dtb_flags & DTRACEBUF_WRAPPED))
                return;

diff --git a/dtrace/dtrace_dif.c b/dtrace/dtrace_dif.c
index a7cdb9f2ad95bee64b07b7510edfadd1f7de3c94..70dbdd2a2cf80dfd10ca1eda9d0e97306e84f2e0 100644 (file)
--- a/dtrace/dtrace_dif.c
+++ b/dtrace/dtrace_dif.c
@@ -671,7 +671,7 @@ void dtrace_difo_init(dtrace_difo_t *dp, dtrace_vstate_t *vstate)
        int     i, oldsvars, osz, nsz, otlocals, ntlocals;
        uint_t  id;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
        ASSERT(dp->dtdo_buf != NULL && dp->dtdo_len != 0);
 
        for (i = 0; i < dp->dtdo_varlen; i++) {
@@ -845,7 +845,7 @@ void dtrace_difo_release(dtrace_difo_t *dp, dtrace_vstate_t *vstate)
 {
        int     i;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
        ASSERT(dp->dtdo_refcnt != 0);
 
        for (i = 0; i < dp->dtdo_varlen; i++) {
@@ -2199,11 +2199,7 @@ static void dtrace_dif_subr(uint_t subr, uint_t rd, uint64_t *regs,
                }
 
                m.mx = dtrace_load64(tupregs[0].dttk_value);
-#ifdef CONFIG_SMP
-               regs[rd] = m.mi.owner != NULL;
-#else
-               regs[rd] = mutex_is_locked(&m.mi);
-#endif
+               regs[rd] = mutex_owned(&m.mi);
                break;
 
        case DIF_SUBR_MUTEX_OWNER:

diff --git a/dtrace/dtrace_dof.c b/dtrace/dtrace_dof.c
index 24f98abbe6dffd133d77e202b2eaf63815263ed8..fcb8978b27db2b66f08b39ee379c852e8f56e925 100644 (file)
--- a/dtrace/dtrace_dof.c
+++ b/dtrace/dtrace_dof.c
@@ -59,7 +59,7 @@ dof_hdr_t *dtrace_dof_create(dtrace_state_t *state)
                                 roundup(sizeof(dof_sec_t), sizeof(uint64_t)) +
                                 sizeof(dof_optdesc_t) * DTRACEOPT_MAX;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
 
        dof = kmalloc(len, GFP_KERNEL);
        dof->dofh_ident[DOF_ID_MAG0] = DOF_MAG_MAG0;
@@ -111,10 +111,7 @@ dof_hdr_t *dtrace_dof_copyin(void __user *argp, int *errp)
 {
        dof_hdr_t       hdr, *dof;
 
-#ifdef FIXME
-       /* This seems to be unnecessary and actually wrong). */
-       ASSERT(!mutex_is_locked(&dtrace_lock));
-#endif
+       ASSERT(!MUTEX_HELD(&dtrace_lock));
 
        /*
         * First, we're going to copyin() the sizeof(dof_hdr_t).
@@ -816,7 +813,7 @@ int dtrace_dof_slurp(dof_hdr_t *dof, dtrace_vstate_t *vstate, const cred_t *cr,
        dtrace_enabling_t       *enab;
        uint_t                  i;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
        ASSERT(dof->dofh_loadsz >= sizeof(dof_hdr_t));
 
        /*

diff --git a/dtrace/dtrace_ecb.c b/dtrace/dtrace_ecb.c
index 8f91dae89f99505ddd7e6ba8315fe83de383eaa7..b34b8c696a6aea494530a920c58c02f8818d3136 100644 (file)
--- a/dtrace/dtrace_ecb.c
+++ b/dtrace/dtrace_ecb.c
@@ -187,7 +187,7 @@ static int dtrace_ecb_action_add(dtrace_ecb_t *ecb, dtrace_actdesc_t *desc)
        dtrace_optval_t         *opt = state->dts_options, nframes, strsize;
        uint64_t                arg = desc->dtad_arg;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
        ASSERT(ecb->dte_action == NULL || ecb->dte_action->dta_refcnt == 1);
 
        if (DTRACEACT_ISAGG(desc->dtad_kind)) {
@@ -450,7 +450,7 @@ void dtrace_ecb_disable(dtrace_ecb_t *ecb)
        dtrace_ecb_t    *pecb, *prev = NULL;
        dtrace_probe_t  *probe = ecb->dte_probe;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
 
        if (probe == NULL)
                return;
@@ -525,7 +525,7 @@ static dtrace_ecb_t *dtrace_ecb_add(dtrace_state_t *state,
        dtrace_ecb_t    *ecb;
        dtrace_epid_t   epid;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
 
        ecb = kzalloc(sizeof(dtrace_ecb_t), GFP_KERNEL);
        ecb->dte_predicate = NULL;
@@ -588,7 +588,7 @@ static dtrace_ecb_t *dtrace_ecb_create(dtrace_state_t *state,
        dtrace_provider_t       *prov;
        dtrace_ecbdesc_t        *desc = enab->dten_current;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
        ASSERT(state != NULL);
 
        ecb = dtrace_ecb_add(state, probe);
@@ -668,7 +668,7 @@ void dtrace_ecb_destroy(dtrace_ecb_t *ecb)
        dtrace_predicate_t      *pred;
        dtrace_epid_t           epid = ecb->dte_epid;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
        ASSERT(ecb->dte_next == NULL);
        ASSERT(ecb->dte_probe == NULL || ecb->dte_probe->dtpr_ecb != ecb);
 
@@ -808,8 +808,8 @@ int dtrace_ecb_enable(dtrace_ecb_t *ecb)
 {
        dtrace_probe_t  *probe = ecb->dte_probe;
 
-       ASSERT(mutex_is_locked(&cpu_lock));
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&cpu_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
        ASSERT(ecb->dte_next == NULL);
 
        if (probe == NULL)
@@ -844,7 +844,7 @@ dtrace_ecb_t *dtrace_epid2ecb(dtrace_state_t *state, dtrace_epid_t id)
 {
        dtrace_ecb_t *ecb;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
 
        if (id == 0 || id > state->dts_necbs)
                return NULL;
@@ -859,7 +859,7 @@ dtrace_ecb_t *dtrace_epid2ecb(dtrace_state_t *state, dtrace_epid_t id)
 dtrace_aggregation_t *dtrace_aggid2agg(dtrace_state_t *state,
                                       dtrace_aggid_t id)
 {
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
 
        return idr_find(&state->dts_agg_idr, id);
 }

diff --git a/dtrace/dtrace_enable.c b/dtrace/dtrace_enable.c
index ae6197f8af2639b49d2d8a1ea5a787fcff097a03..720b35253ca3d0e09925132da25d930ce281d735 100644 (file)
--- a/dtrace/dtrace_enable.c
+++ b/dtrace/dtrace_enable.c
@@ -128,7 +128,7 @@ void dtrace_enabling_destroy(dtrace_enabling_t *enab)
        dtrace_ecbdesc_t        *ep;
        dtrace_vstate_t         *vstate = enab->dten_vstate;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
 
        for (i = 0; i < enab->dten_ndesc; i++) {
                dtrace_actdesc_t        *act, *next;
@@ -186,7 +186,7 @@ int dtrace_enabling_retain(dtrace_enabling_t *enab)
 {
        dtrace_state_t  *state;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
        ASSERT(enab->dten_next == NULL && enab->dten_prev == NULL);
        ASSERT(enab->dten_vstate != NULL);
 
@@ -220,7 +220,7 @@ int dtrace_enabling_replicate(dtrace_state_t *state, dtrace_probedesc_t *match,
        dtrace_enabling_t       *new, *enab;
        int                     found = 0, err = -ENOENT;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
        ASSERT(strlen(match->dtpd_provider) < DTRACE_PROVNAMELEN);
        ASSERT(strlen(match->dtpd_mod) < DTRACE_MODNAMELEN);
        ASSERT(strlen(match->dtpd_func) < DTRACE_FUNCNAMELEN);
@@ -285,7 +285,7 @@ void dtrace_enabling_retract(dtrace_state_t *state)
 {
        dtrace_enabling_t       *enab, *next;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
 
        /*
         * Iterate over all retained enablings, destroy the enablings retained

diff --git a/dtrace/dtrace_predicate.c b/dtrace/dtrace_predicate.c
index b384e33cf62ac85d709e26d8484e0d1aa5c8aef7..dc2b2ad3ae1d61dca3c96a843d904c38bcd4bcf8 100644 (file)
--- a/dtrace/dtrace_predicate.c
+++ b/dtrace/dtrace_predicate.c
@@ -35,7 +35,7 @@ dtrace_predicate_t *dtrace_predicate_create(dtrace_difo_t *dp)
 {
        dtrace_predicate_t      *pred;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
        ASSERT(dp->dtdo_refcnt != 0);
 
        pred = kzalloc(sizeof (dtrace_predicate_t), GFP_KERNEL);
@@ -63,7 +63,7 @@ dtrace_predicate_t *dtrace_predicate_create(dtrace_difo_t *dp)
 
 void dtrace_predicate_hold(dtrace_predicate_t *pred)
 {
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
        ASSERT(pred->dtp_difo != NULL && pred->dtp_difo->dtdo_refcnt != 0);
        ASSERT(pred->dtp_refcnt > 0);
 
@@ -75,7 +75,7 @@ void dtrace_predicate_release(dtrace_predicate_t *pred,
 {
        dtrace_difo_t *dp = pred->dtp_difo;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
        ASSERT(dp != NULL && dp->dtdo_refcnt != 0);
        ASSERT(pred->dtp_refcnt > 0);
 

diff --git a/dtrace/dtrace_probe.c b/dtrace/dtrace_probe.c
index 053316c7582428f7c96408d11bbe86f6a3df6729..f188058571c431ea2469f8049db2fe2bbd7c6b21 100644 (file)
--- a/dtrace/dtrace_probe.c
+++ b/dtrace/dtrace_probe.c
@@ -68,7 +68,7 @@ dtrace_id_t dtrace_probe_create(dtrace_provider_id_t prov, const char *mod,
         * held when we enter this function.
         */
        if (provider == dtrace_provider) {
-               ASSERT(mutex_is_locked(&dtrace_lock));
+               ASSERT(MUTEX_HELD(&dtrace_lock));
                mutex_unlock(&dtrace_lock);
        }
 
@@ -1217,12 +1217,6 @@ dtrace_id_t dtrace_probe_lookup(dtrace_provider_id_t prid, const char *mod,
        dtrace_id_t             id;
        int                     match;
 
-       /* FIXME: Maybe?  We really should protect against this. */
-       if (mutex_is_locked(&dtrace_lock)) {
-               WARN(1, "dtrace_probe_lookup() called with dtrace_lock held!");
-               return 0;
-       }
-
        pkey.dtpk_prov = ((dtrace_provider_t *)prid)->dtpv_name;
        pkey.dtpk_pmatch = &dtrace_match_string;
        pkey.dtpk_mod = mod;

diff --git a/dtrace/dtrace_ptofapi.c b/dtrace/dtrace_ptofapi.c
index 88df66704cd49e9eab551662e87496dd2d375b55..0f70f34adb32d98a6bec8ba64f39e5751f9c623d 100644 (file)
--- a/dtrace/dtrace_ptofapi.c
+++ b/dtrace/dtrace_ptofapi.c
@@ -129,8 +129,8 @@ int dtrace_register(const char *name, const dtrace_pattr_t *pap, uint32_t priv,
        *idp = (dtrace_provider_id_t)provider;
 
        if (pops == &dtrace_provider_ops) {
-               ASSERT(mutex_is_locked(&dtrace_provider_lock));
-               ASSERT(mutex_is_locked(&dtrace_lock));
+               ASSERT(MUTEX_HELD(&dtrace_provider_lock));
+               ASSERT(MUTEX_HELD(&dtrace_lock));
                ASSERT(dtrace_anon.dta_enabling == NULL);
 
                /*
@@ -249,8 +249,8 @@ int dtrace_unregister(dtrace_provider_id_t id)
                 * with locks already held.
                 */
                ASSERT(old == dtrace_provider);
-               ASSERT(mutex_is_locked(&dtrace_provider_lock));
-               ASSERT(mutex_is_locked(&dtrace_lock));
+               ASSERT(MUTEX_HELD(&dtrace_provider_lock));
+               ASSERT(MUTEX_HELD(&dtrace_lock));
 
                self = 1;
 

diff --git a/dtrace/dtrace_state.c b/dtrace/dtrace_state.c
index 91ba3fbe2b8a8fc1f65053871a302961ca74d0b8..14035688af73a28ca4ac47b01e8923cceae0d4c9 100644 (file)
--- a/dtrace/dtrace_state.c
+++ b/dtrace/dtrace_state.c
@@ -158,7 +158,7 @@ int dtrace_dstate_init(dtrace_dstate_t *dstate, size_t size)
        dtrace_dynvar_t *dvar, *next, *start;
        int             i;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
        ASSERT(dstate->dtds_base == NULL && dstate->dtds_percpu == NULL);
 
        memset(dstate, 0, sizeof (dtrace_dstate_t));
@@ -250,7 +250,7 @@ int dtrace_dstate_init(dtrace_dstate_t *dstate, size_t size)
 
 void dtrace_dstate_fini(dtrace_dstate_t *dstate)
 {
-       ASSERT(mutex_is_locked(&cpu_lock));
+       ASSERT(MUTEX_HELD(&cpu_lock));
 
        if (dstate->dtds_base == NULL)
                return;
@@ -328,8 +328,8 @@ dtrace_state_t *dtrace_state_create(struct file *file)
        int             err;
        dtrace_aggid_t  aggid;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
-       ASSERT(mutex_is_locked(&cpu_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&cpu_lock));
 
        state = kzalloc(sizeof (dtrace_state_t), GFP_KERNEL);
        state->dts_epid = DTRACE_EPIDNONE + 1;
@@ -476,8 +476,8 @@ static int dtrace_state_buffer(dtrace_state_t *state, dtrace_buffer_t *buf,
        processorid_t   cpu = DTRACE_CPUALL;
        int             flags = 0, rval;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
-       ASSERT(mutex_is_locked(&cpu_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&cpu_lock));
        ASSERT(which < DTRACEOPT_MAX);
        ASSERT(state->dts_activity == DTRACE_ACTIVITY_INACTIVE ||
               (state == dtrace_anon.dta_state &&
@@ -857,7 +857,7 @@ int dtrace_state_stop(dtrace_state_t *state, processorid_t *cpu)
 {
        dtrace_icookie_t        cookie;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
 
        if (state->dts_activity != DTRACE_ACTIVITY_ACTIVE &&
            state->dts_activity != DTRACE_ACTIVITY_DRAINING)
@@ -907,7 +907,7 @@ int dtrace_state_stop(dtrace_state_t *state, processorid_t *cpu)
 int dtrace_state_option(dtrace_state_t *state, dtrace_optid_t option,
                        dtrace_optval_t val)
 {
-       ASSERT(mutex_is_locked(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
 
        if (state->dts_activity != DTRACE_ACTIVITY_INACTIVE)
                return -EBUSY;
@@ -965,8 +965,8 @@ void dtrace_state_destroy(dtrace_state_t *state)
        int                     nspec = state->dts_nspeculations;
        uint32_t                match;
 
-       ASSERT(mutex_is_locked(&dtrace_lock));
-       ASSERT(mutex_is_locked(&cpu_lock));
+       ASSERT(MUTEX_HELD(&dtrace_lock));
+       ASSERT(MUTEX_HELD(&cpu_lock));
 
        /*
         * First, retract any retained enablings for this state.

diff --git a/dtrace/profile_dev.c b/dtrace/profile_dev.c
index 95e7ad99c0f13a6e163b1c475ed47dcb72734740..38a65e4ac10c378f8ff1f43a5f2e553591a75e30 100644 (file)
--- a/dtrace/profile_dev.c
+++ b/dtrace/profile_dev.c
@@ -341,7 +341,7 @@ int profile_enable(void *arg, dtrace_id_t id, void *parg)
        cyc_time_t              when;
 
        ASSERT(ktime_nz(prof->prof_interval));
-       ASSERT(mutex_is_locked(&cpu_lock));
+       ASSERT(MUTEX_HELD(&cpu_lock));
 
        if (prof->prof_kind == PROF_TICK) {
                hdlr.cyh_func = profile_tick;
@@ -372,7 +372,7 @@ void profile_disable(void *arg, dtrace_id_t id, void *parg)
        profile_probe_t *prof = parg;
 
        ASSERT(prof->prof_cyclic != CYCLIC_NONE);
-       ASSERT(mutex_is_locked(&cpu_lock));
+       ASSERT(MUTEX_HELD(&cpu_lock));
 
        cyclic_remove(prof->prof_cyclic);
        prof->prof_cyclic = CYCLIC_NONE;