Lines Matching refs:probe
47 * - Non-probe context utility functions
219 static vmem_t *dtrace_arena; /* probe ID arena */
240 static dtrace_genid_t dtrace_probegen; /* current probe generation */
274 * etc. Importantly, dtrace_lock is _not_ required when in probe context;
275 * probe context is lock-free -- synchronization is handled via the
300 static kmutex_t dtrace_lock; /* probe state lock */
321 static lck_mtx_t dtrace_lock; /* probe state lock */
364 static dtrace_id_t dtrace_probeid_begin; /* special BEGIN probe */
365 static dtrace_id_t dtrace_probeid_end; /* special END probe */
366 dtrace_id_t dtrace_probeid_error; /* special ERROR probe */
410 #define DTRACE_HASHSTR(hash, probe) \
411 dtrace_hash_str(*((char **)((uintptr_t)(probe) + (hash)->dth_stroffs)))
413 #define DTRACE_HASHNEXT(hash, probe) \
414 (dtrace_probe_t **)((uintptr_t)(probe) + (hash)->dth_nextoffs)
416 #define DTRACE_HASHPREV(hash, probe) \
417 (dtrace_probe_t **)((uintptr_t)(probe) + (hash)->dth_prevoffs)
678 #define DTRACE_ANCHORED(probe) ((probe)->dtpr_func[0] != '\0')
726 * These functions are called from probe context. Because probe context is
729 * As a result, functions called from probe context may only call other DTrace
731 * (Note that the ASSERT macro is made probe-context safe by redefining it in
732 * terms of dtrace_assfail(), a probe-context safe function.) If arbitrary
733 * loads are to be performed from probe context, they _must_ be in terms of
736 * Some functions in this block are not actually called from probe context;
738 * "Note: not called from probe context."
754 * Atomically increment a specified error counter from probe context.
760 * Most counters stored to in probe context are per-CPU counters.
1480 * Note: not called from probe context. This function is called
1481 * asynchronously (and at a regular interval) from outside of probe context to
2699 * Note: not called from probe context. This function is called
2749 * Note: not called from probe context. This function is called
2917 * The easy case: this probe is allowed to read all of memory, so
3141 * If this is an unanchored probe, we are
3226 * Note that we are assuming that an unanchored probe is
3249 * Note that we are assuming that an unanchored probe is
3254 /* Anchored probe that fires while on an interrupt accrues to process 0 */
4206 * valid within multiple enablings of the same probe --
6069 dtrace_probe_t *probe = ecb->dte_probe;
6070 dtrace_provider_t *prov = probe->dtpr_provider;
6073 char *msg = "dtrace: breakpoint action at probe ";
6076 const char *msg = "dtrace: breakpoint action at probe ";
6087 * It's impossible to be taking action on the NULL probe.
6089 ASSERT(probe != NULL);
6094 * the probe, along with the hex address of the ECB with the breakpoint
6105 for (str = probe->dtpr_mod; *str != '\0'; str++)
6109 for (str = probe->dtpr_func; *str != '\0'; str++)
6113 for (str = probe->dtpr_name; *str != '\0'; str++)
6136 dtrace_probe_t *probe = ecb->dte_probe;
6139 * It's impossible to be taking action on the NULL probe.
6141 ASSERT(probe != NULL);
6162 panic("dtrace: panic action at probe %s:%s:%s:%s (ecb %p)",
6163 probe->dtpr_provider->dtpv_name, probe->dtpr_mod,
6164 probe->dtpr_func, probe->dtpr_name, (void *)ecb);
6421 * is the function called by the provider to fire a probe -- from which all
6422 * subsequent probe-context DTrace activity emanates.
6436 dtrace_probe_t *probe;
6459 probe = dtrace_probes[id - 1];
6464 if (!onintr && probe->dtpr_predcache != DTRACE_CACHEIDNONE &&
6465 probe->dtpr_predcache == curthread->t_predcache) {
6467 if (!onintr && probe->dtpr_predcache != DTRACE_CACHEIDNONE &&
6468 probe->dtpr_predcache == dtrace_get_thread_predcache(current_thread())) {
6520 * 0 through "arg0" and the probe_id of the overridden probe as arg1. Detect that here
6542 mstate.dtms_probe = probe;
6552 for (ecb = probe->dtpr_ecb; ecb != NULL; ecb = ecb->dte_next) {
6558 dtrace_provider_t *prov = probe->dtpr_provider;
6583 * If dtrace itself is the provider of this probe,
6603 * probe. If we are, we will only continue processing
6608 if (probe->dtpr_id == dtrace_probeid_begin &&
6620 * of this probe, call the provider's dtps_usermode()
6621 * entry point to check that the probe was fired
6627 probe->dtpr_id, probe->dtpr_arg) == 0)
6743 dtrace_cacheid_t cid = probe->dtpr_predcache;
6818 size / sizeof (pc_t), probe->dtpr_aframes,
6819 DTRACE_ANCHORED(probe) ? NULL :
6823 size / sizeof (pc_t), probe->dtpr_aframes,
6824 DTRACE_ANCHORED(probe) ? NULL :
7108 if (probe->dtpr_id == dtrace_probeid_error) {
7111 * error on the error probe. We bump an
7183 /* Don't allow a thread to re-enter dtrace_probe(). This could occur if a probe is encountered
7213 * sections) are not _called_ from probe context. (Any exceptions to this are
7216 * the DTrace probe hashes. (Each probe is hashed by each element of the
7217 * probe tuple -- allowing for fast lookups, regardless of what was
7288 dtrace_probe_t *probe = bucket->dthb_chain;
7290 ASSERT(probe != NULL);
7291 ndx = DTRACE_HASHSTR(hash, probe) & new_mask;
7375 dtrace_hash_remove(dtrace_hash_t *hash, dtrace_probe_t *probe)
7377 int ndx = DTRACE_HASHSTR(hash, probe) & hash->dth_mask;
7380 dtrace_probe_t **prevp = DTRACE_HASHPREV(hash, probe);
7381 dtrace_probe_t **nextp = DTRACE_HASHNEXT(hash, probe);
7384 * Find the bucket that we're removing this probe from.
7387 if (DTRACE_HASHEQ(hash, bucket->dthb_chain, probe))
7396 * The removed probe was the only probe on this
7401 ASSERT(bucket->dthb_chain == probe);
7430 * These are random utility functions that are _not_ called from probe context.
7567 * a probe tuple, or some globbed expressions for elements of a probe tuple.
7794 dtrace_probe_t template, *probe;
7802 * If the probe ID is specified in the key, just lookup by ID and
7803 * invoke the match callback once if a matching probe is found.
7806 if ((probe = dtrace_probe_lookup_id(pkp->dtpk_id)) != NULL &&
7807 dtrace_match_probe(probe, pkp, priv, uid, zoneid) > 0) {
7808 if ((*matched)(probe, arg) == DTRACE_MATCH_FAIL)
7850 * If we did not select a hash table, iterate over every probe and
7851 * invoke our callback for each one that matches our input probe key.
7859 if ((probe = dtrace_probes[i]) == NULL ||
7860 dtrace_match_probe(probe, pkp, priv, uid,
7866 if ((rc = (*matched)(probe, arg)) != DTRACE_MATCH_NEXT) {
7877 * If we selected a hash table, iterate over each probe of the same key
7878 * name and invoke the callback for every probe that matches the other
7879 * attributes of our input probe key.
7881 for (probe = dtrace_hash_lookup(hash, &template); probe != NULL;
7882 probe = *(DTRACE_HASHNEXT(hash, probe))) {
7884 if (dtrace_match_probe(probe, pkp, priv, uid, zoneid) <= 0)
7889 if ((rc = (*matched)(probe, arg)) != DTRACE_MATCH_NEXT) {
7922 * Build a probe comparison key for use with dtrace_match_probe() from the
7923 * given probe description. By convention, a null key only matches anchored
7957 * the functions in the API for probe management (found below), and
8118 dtrace_probe_t *probe, *first = NULL;
8164 if ((probe = dtrace_probes[i]) == NULL)
8167 if (probe->dtpr_provider != old)
8170 if (probe->dtpr_ecb == NULL)
8186 * remove all of them from their hash chains and from the probe array.
8189 if ((probe = dtrace_probes[i]) == NULL)
8192 if (probe->dtpr_provider != old)
8197 dtrace_hash_remove(dtrace_bymod, probe);
8198 dtrace_hash_remove(dtrace_byfunc, probe);
8199 dtrace_hash_remove(dtrace_byname, probe);
8202 first = probe;
8203 probe->dtpr_nextmod = NULL;
8205 probe->dtpr_nextmod = first;
8206 first = probe;
8212 * from the probe array. Now issue a dtrace_sync() to be sure that
8213 * everyone has cleared out from any probe array processing.
8217 for (probe = first; probe != NULL; probe = first) {
8218 first = probe->dtpr_nextmod;
8220 old->dtpv_pops.dtps_destroy(old->dtpv_arg, probe->dtpr_id,
8221 probe->dtpr_arg);
8222 kmem_free(probe->dtpr_mod, strlen(probe->dtpr_mod) + 1);
8223 kmem_free(probe->dtpr_func, strlen(probe->dtpr_func) + 1);
8224 kmem_free(probe->dtpr_name, strlen(probe->dtpr_name) + 1);
8225 vmem_free(dtrace_arena, (void *)(uintptr_t)(probe->dtpr_id), 1);
8227 kmem_free(probe, sizeof (dtrace_probe_t));
8229 zfree(dtrace_probe_t_zone, probe);
8262 * Invalidate the specified provider. All subsequent probe lookups for the
8306 dtrace_probe_t *probe;
8321 if ((probe = dtrace_probes[i]) == NULL)
8324 if (probe->dtpr_provider != prov)
8327 if (probe->dtpr_ecb != NULL)
8332 dtrace_hash_remove(dtrace_bymod, probe);
8333 dtrace_hash_remove(dtrace_byfunc, probe);
8334 dtrace_hash_remove(dtrace_byname, probe);
8337 probe->dtpr_arg);
8338 kmem_free(probe->dtpr_mod, strlen(probe->dtpr_mod) + 1);
8339 kmem_free(probe->dtpr_func, strlen(probe->dtpr_func) + 1);
8340 kmem_free(probe->dtpr_name, strlen(probe->dtpr_name) + 1);
8342 kmem_free(probe, sizeof (dtrace_probe_t));
8344 zfree(dtrace_probe_t_zone, probe);
8358 * The functions in this section perform the DTrace probe management,
8366 * Create a probe with the specified module name, function name, and name.
8372 dtrace_probe_t *probe, **probes;
8385 probe = kmem_zalloc(sizeof (dtrace_probe_t), KM_SLEEP);
8387 probe = zalloc(dtrace_probe_t_zone);
8388 bzero(probe, sizeof (dtrace_probe_t));
8391 probe->dtpr_id = id;
8392 probe->dtpr_gen = dtrace_probegen++;
8393 probe->dtpr_mod = dtrace_strdup(mod);
8394 probe->dtpr_func = dtrace_strdup(func);
8395 probe->dtpr_name = dtrace_strdup(name);
8396 probe->dtpr_arg = arg;
8397 probe->dtpr_aframes = aframes;
8398 probe->dtpr_provider = provider;
8400 dtrace_hash_add(dtrace_bymod, probe);
8401 dtrace_hash_add(dtrace_byfunc, probe);
8402 dtrace_hash_add(dtrace_byname, probe);
8449 dtrace_probes[id - 1] = probe;
8474 dtrace_probe_lookup_match(dtrace_probe_t *probe, void *arg)
8476 *((dtrace_id_t *)arg) = probe->dtpr_id;
8482 * Look up a probe based on provider and one or more of module name, function
8483 * name and probe name.
8513 * Returns the probe argument associated with the specified probe.
8518 dtrace_probe_t *probe;
8523 if ((probe = dtrace_probe_lookup_id(pid)) != NULL &&
8524 probe->dtpr_provider == (dtrace_provider_t *)id)
8525 rval = probe->dtpr_arg;
8533 * Copy a probe into a probe description.
8559 * Called to indicate that a probe -- or probes -- should be provided by a
8564 * opportunity to dynamically provide the specified probe, allowing providers
8622 * Iterate over each probe, and call the Framework-to-Provider API function
8630 dtrace_probe_t *probe;
8635 * We disable interrupts to walk through the probe array. This is
8642 if ((probe = dtrace_probes[i]) == NULL)
8645 if (probe->dtpr_ecb == NULL) {
8647 * This probe isn't enabled -- don't call the function.
8652 prov = probe->dtpr_provider;
8656 func(prov->dtpv_arg, i + 1, probe->dtpr_arg);
8677 * create an ECB with a NULL probe.
8726 dof_probe_t *probe;
8778 probe = (dof_probe_t *)(uintptr_t)(daddr +
8782 dhpb.dthpb_func = strtab + probe->dofpr_func;
8783 dhpb.dthpb_name = strtab + probe->dofpr_name;
8785 dhpb.dthpb_base = probe->dofpr_addr;
8790 dhpb.dthpb_offs = off + probe->dofpr_offidx;
8792 dhpb.dthpb_offs = (int32_t *)(off + probe->dofpr_offidx);
8794 dhpb.dthpb_noffs = probe->dofpr_noffs;
8797 dhpb.dthpb_enoffs = enoff + probe->dofpr_enoffidx;
8799 dhpb.dthpb_enoffs = (int32_t *)(enoff + probe->dofpr_enoffidx);
8801 dhpb.dthpb_nenoffs = probe->dofpr_nenoffs;
8806 dhpb.dthpb_args = arg + probe->dofpr_argidx;
8807 dhpb.dthpb_nargc = probe->dofpr_nargc;
8808 dhpb.dthpb_xargc = probe->dofpr_xargc;
8809 dhpb.dthpb_ntypes = strtab + probe->dofpr_nargv;
8810 dhpb.dthpb_xtypes = strtab + probe->dofpr_xargv;
10337 dtrace_ecb_add(dtrace_state_t *state, dtrace_probe_t *probe)
10346 ecb->dte_probe = probe;
10414 dtrace_probe_t *probe = ecb->dte_probe;
10420 if (probe == NULL) {
10422 * This is the NULL probe -- there's nothing to do.
10427 if (probe->dtpr_ecb == NULL) {
10428 dtrace_provider_t *prov = probe->dtpr_provider;
10431 * We're the first ECB on this probe.
10433 probe->dtpr_ecb = probe->dtpr_ecb_last = ecb;
10436 probe->dtpr_predcache = ecb->dte_predicate->dtp_cacheid;
10439 probe->dtpr_id, probe->dtpr_arg));
10442 * This probe is already active. Swing the last pointer to
10446 ASSERT(probe->dtpr_ecb_last != NULL);
10447 probe->dtpr_ecb_last->dte_next = ecb;
10448 probe->dtpr_ecb_last = ecb;
10449 probe->dtpr_predcache = 0;
11051 * We disable the ECB by removing it from its probe.
11054 dtrace_probe_t *probe = ecb->dte_probe;
11058 if (probe == NULL) {
11060 * This is the NULL probe; there is nothing to disable.
11065 for (pecb = probe->dtpr_ecb; pecb != NULL; pecb = pecb->dte_next) {
11074 probe->dtpr_ecb = ecb->dte_next;
11079 if (ecb == probe->dtpr_ecb_last) {
11081 probe->dtpr_ecb_last = prev;
11085 * The ECB has been disconnected from the probe; now sync to assure
11090 if (probe->dtpr_ecb == NULL) {
11092 * That was the last ECB on the probe; clear the predicate
11093 * cache ID for the probe, disable it and sync one more time
11096 dtrace_provider_t *prov = probe->dtpr_provider;
11099 ASSERT(probe->dtpr_ecb_last == NULL);
11100 probe->dtpr_predcache = DTRACE_CACHEIDNONE;
11102 probe->dtpr_id, probe->dtpr_arg);
11106 * There is at least one ECB remaining on the probe. If there
11107 * is _exactly_ one, set the probe's predicate cache ID to be
11110 ASSERT(probe->dtpr_ecb_last != NULL);
11111 ASSERT(probe->dtpr_predcache == DTRACE_CACHEIDNONE);
11113 if (probe->dtpr_ecb == probe->dtpr_ecb_last) {
11114 dtrace_predicate_t *p = probe->dtpr_ecb->dte_predicate;
11116 ASSERT(probe->dtpr_ecb->dte_next == NULL);
11119 probe->dtpr_predcache = p->dtp_cacheid;
11150 dtrace_ecb_create(dtrace_state_t *state, dtrace_probe_t *probe,
11162 ecb = dtrace_ecb_add(state, probe);
11170 if (probe != NULL) {
11180 * and DTRACE_COND_ZONEOWNER will then do at probe time.
11182 prov = probe->dtpr_provider;
11235 dtrace_ecb_create_enable(dtrace_probe_t *probe, void *arg)
11243 if (probe != NULL && probe->dtpr_gen < enab->dten_probegen) {
11245 * This probe was created in a generation for which this
11252 if ((ecb = dtrace_ecb_create(state, probe, enab)) == NULL)
11360 * that processes the BEGIN probe has its buffer activated
11462 * Note: called from probe context. This function just increments the drop
11475 * Note: called from probe context. This function is called to reserve space
11617 * the previous failed probe attempt. But at
11871 * specified ECB in every way, but has the specified probe description.
11897 cmn_err(CE_NOTE, "enabling probe %d (%s:%s:%s:%s)", i,
12030 * Now iterate over each probe description; we're looking for
12031 * an exact match to the specified probe description.
12064 * We have a winning probe! Add it to our growing
12125 * If a provider failed to enable a probe then get out and
12206 * NULL probe -- which is exactly what this function does.
12588 dof_probedesc_t *probe;
12595 dtrace_dof_error(dof, "invalid probe section");
12600 dtrace_dof_error(dof, "bad alignment in probe description");
12605 dtrace_dof_error(dof, "truncated probe description");
12609 probe = (dof_probedesc_t *)(uintptr_t)(daddr + sec->dofs_offset);
12610 strtab = dtrace_dof_sect(dof, DOF_SECT_STRTAB, probe->dofp_strtab);
12618 if (probe->dofp_provider >= strtab->dofs_size) {
12619 dtrace_dof_error(dof, "corrupt probe provider");
12624 (char *)(str + probe->dofp_provider),
12625 MIN(DTRACE_PROVNAMELEN - 1, size - probe->dofp_provider));
12630 if (probe->dofp_mod >= strtab->dofs_size) {
12631 dtrace_dof_error(dof, "corrupt probe module");
12635 (void) strncpy(desc->dtpd_mod, (char *)(str + probe->dofp_mod),
12636 MIN(DTRACE_MODNAMELEN - 1, size - probe->dofp_mod));
12641 if (probe->dofp_func >= strtab->dofs_size) {
12642 dtrace_dof_error(dof, "corrupt probe function");
12646 (void) strncpy(desc->dtpd_func, (char *)(str + probe->dofp_func),
12647 MIN(DTRACE_FUNCNAMELEN - 1, size - probe->dofp_func));
12652 if (probe->dofp_name >= strtab->dofs_size) {
12653 dtrace_dof_error(dof, "corrupt probe name");
12657 (void) strncpy(desc->dtpd_name, (char *)(str + probe->dofp_name),
12658 MIN(DTRACE_NAMELEN - 1, size - probe->dofp_name));
13701 * other hand, it saves an additional memory reference in the probe
13735 * Depending on the user credentials, we set flag bits which alter probe
13749 * examine the credential and the zone from probe context.
13978 dtrace_probe_t *probe;
13989 probe = dtrace_probes[dtrace_probeid_end - 1];
13990 ASSERT(probe != NULL);
13992 for (ecb = probe->dtpr_ecb; ecb != NULL; ecb = ecb->dte_next) {
14214 * Now it's time to actually fire the BEGIN probe. We need to disable
14216 * probe (the data from this CPU will be processed first at user
14228 * We may have had an exit action from a BEGIN probe; only change our
14241 * processing an ECB halfway down a probe's ECB chain; all CPUs will
14305 * iff we're in the END probe.
14312 * Finally, we can release the reserve and call the END probe. We
14313 * disable interrupts across calling the END probe to allow us to
14314 * return the CPU on which we actually called the END probe. This
14415 * issue a sync to be sure that everyone is out of probe
14441 dtrace_probe_t *probe = ecb->dte_probe;
14442 dtrace_provider_t *prov = probe->dtpr_provider;
14458 * every CPU is out of probe context.
15179 dof_probe_t *probe;
15265 probe = (dof_probe_t *)(uintptr_t)(daddr +
15268 if (probe->dofpr_func >= str_sec->dofs_size) {
15273 if (strlen(strtab + probe->dofpr_func) >= DTRACE_FUNCNAMELEN) {
15278 if (probe->dofpr_name >= str_sec->dofs_size ||
15279 strlen(strtab + probe->dofpr_name) >= DTRACE_NAMELEN) {
15280 dtrace_dof_error(dof, "invalid probe name");
15288 if (probe->dofpr_offidx + probe->dofpr_noffs <
15289 probe->dofpr_offidx ||
15290 (probe->dofpr_offidx + probe->dofpr_noffs) *
15292 dtrace_dof_error(dof, "invalid probe offset");
15300 * perform the same checks as for probe offsets
15304 if (probe->dofpr_enoffidx != 0 ||
15305 probe->dofpr_nenoffs != 0) {
15310 } else if (probe->dofpr_enoffidx +
15311 probe->dofpr_nenoffs < probe->dofpr_enoffidx ||
15312 (probe->dofpr_enoffidx + probe->dofpr_nenoffs) *
15319 if (probe->dofpr_noffs + probe->dofpr_nenoffs == 0) {
15320 dtrace_dof_error(dof, "zero probe and "
15324 } else if (probe->dofpr_noffs == 0) {
15325 dtrace_dof_error(dof, "zero probe offsets");
15329 if (probe->dofpr_argidx + probe->dofpr_xargc <
15330 probe->dofpr_argidx ||
15331 (probe->dofpr_argidx + probe->dofpr_xargc) *
15337 typeidx = probe->dofpr_nargv;
15338 typestr = strtab + probe->dofpr_nargv;
15339 for (k = 0; k < probe->dofpr_nargc; k++) {
15356 typeidx = probe->dofpr_xargv;
15357 typestr = strtab + probe->dofpr_xargv;
15358 for (k = 0; k < probe->dofpr_xargc; k++) {
15359 if (arg[probe->dofpr_argidx + k] > probe->dofpr_nargc) {
16480 dtrace_probe_t template, *probe, *first, *next;
16500 for (probe = first = dtrace_hash_lookup(dtrace_bymod, &template);
16501 probe != NULL; probe = probe->dtpr_nextmod) {
16502 if (probe->dtpr_ecb != NULL) {
16509 * unloading a module that has an enabled probe in it.
16515 * probe, either.
16526 probe = first;
16528 for (first = NULL; probe != NULL; probe = next) {
16529 ASSERT(dtrace_probes[probe->dtpr_id - 1] == probe);
16531 dtrace_probes[probe->dtpr_id - 1] = NULL;
16533 next = probe->dtpr_nextmod;
16534 dtrace_hash_remove(dtrace_bymod, probe);
16535 dtrace_hash_remove(dtrace_byfunc, probe);
16536 dtrace_hash_remove(dtrace_byname, probe);
16539 first = probe;
16540 probe->dtpr_nextmod = NULL;
16542 probe->dtpr_nextmod = first;
16543 first = probe;
16549 * from the probe array. Now issue a dtrace_sync() to be sure that
16550 * everyone has cleared out from any probe array processing.
16554 for (probe = first; probe != NULL; probe = first) {
16555 first = probe->dtpr_nextmod;
16556 prov = probe->dtpr_provider;
16557 prov->dtpv_pops.dtps_destroy(prov->dtpv_arg, probe->dtpr_id,
16558 probe->dtpr_arg);
16559 kmem_free(probe->dtpr_mod, strlen(probe->dtpr_mod) + 1);
16560 kmem_free(probe->dtpr_func, strlen(probe->dtpr_func) + 1);
16561 kmem_free(probe->dtpr_name, strlen(probe->dtpr_name) + 1);
16562 vmem_free(dtrace_arena, (void *)(uintptr_t)probe->dtpr_id, 1);
16563 kmem_free(probe, sizeof (dtrace_probe_t));
16579 dtrace_probe_t template, *probe, *first, *next;
16649 for (probe = first = dtrace_hash_lookup(dtrace_bymod, &template);
16650 probe != NULL; probe = probe->dtpr_nextmod) {
16651 if (probe->dtpr_ecb != NULL) {
16654 * unloading a module that has an enabled probe in it.
16660 * probe, either.
16681 probe = first;
16683 for (first = NULL; probe != NULL; probe = next) {
16684 ASSERT(dtrace_probes[probe->dtpr_id - 1] == probe);
16686 dtrace_probes[probe->dtpr_id - 1] = NULL;
16688 next = probe->dtpr_nextmod;
16689 dtrace_hash_remove(dtrace_bymod, probe);
16690 dtrace_hash_remove(dtrace_byfunc, probe);
16691 dtrace_hash_remove(dtrace_byname, probe);
16694 first = probe;
16695 probe->dtpr_nextmod = NULL;
16697 probe->dtpr_nextmod = first;
16698 first = probe;
16704 * from the probe array. Now issue a dtrace_sync() to be sure that
16705 * everyone has cleared out from any probe array processing.
16709 for (probe = first; probe != NULL; probe = first) {
16710 first = probe->dtpr_nextmod;
16711 prov = probe->dtpr_provider;
16712 prov->dtpv_pops.dtps_destroy(prov->dtpv_arg, probe->dtpr_id,
16713 probe->dtpr_arg);
16714 kmem_free(probe->dtpr_mod, strlen(probe->dtpr_mod) + 1);
16715 kmem_free(probe->dtpr_func, strlen(probe->dtpr_func) + 1);
16716 kmem_free(probe->dtpr_name, strlen(probe->dtpr_name) + 1);
16717 vmem_free(dtrace_arena, (void *)(uintptr_t)probe->dtpr_id, 1);
16719 zfree(dtrace_probe_t_zone, probe);
17167 * call to probe provide and before we set LAZY_OFF will be marked as
17635 dtrace_probe_t *probe = NULL;
17653 * Before we attempt to match this probe, we want to give
17674 if ((probe = dtrace_probes[i - 1]) != NULL &&
17675 (m = dtrace_match_probe(probe, &pkey,
17687 if ((probe = dtrace_probes[i - 1]) != NULL &&
17688 dtrace_match_priv(probe, priv, uid, zoneid))
17693 if (probe == NULL) {
17698 dtrace_probe_description(probe, &desc);
17709 dtrace_probe_t *probe;
17732 if ((probe = dtrace_probes[desc.dtargd_id - 1]) == NULL) {
17741 prov = probe->dtpr_provider;
17745 * There isn't any typed information for this probe.
17755 probe->dtpr_id, probe->dtpr_arg, &desc);
18541 dtrace_probe_t *probe = NULL;
18559 * Before we attempt to match this probe, we want to give
18581 if ((probe = dtrace_probes[i - 1]) != NULL &&
18582 (m = dtrace_match_probe(probe, &pkey,
18595 if ((probe = dtrace_probes[i - 1]) != NULL &&
18596 dtrace_match_priv(probe, priv, uid, zoneid))
18601 if (probe == NULL) {
18606 dtrace_probe_description(probe, &desc);
18617 dtrace_probe_t *probe;
18641 if ((probe = dtrace_probes[desc.dtargd_id - 1]) == NULL) {
18650 prov = probe->dtpr_provider;
18654 * There isn't any typed information for this probe.
18664 probe->dtpr_id, probe->dtpr_arg, &desc);
19406 nulldev, /* probe */