Lines Matching defs:probe
46 * - Non-probe context utility functions
229 static vmem_t *dtrace_arena; /* probe ID arena */
256 static dtrace_genid_t dtrace_probegen; /* current probe generation */
275 * etc. Importantly, dtrace_lock is _not_ required when in probe context;
276 * probe context is lock-free -- synchronization is handled via the
299 static kmutex_t dtrace_lock; /* probe state lock */
365 static dtrace_id_t dtrace_probeid_begin; /* special BEGIN probe */
366 static dtrace_id_t dtrace_probeid_end; /* special END probe */
367 dtrace_id_t dtrace_probeid_error; /* special ERROR probe */
412 #define DTRACE_HASHSTR(hash, probe) \
413 dtrace_hash_str(*((char **)((uintptr_t)(probe) + (hash)->dth_stroffs)))
415 #define DTRACE_HASHNEXT(hash, probe) \
416 (dtrace_probe_t **)((uintptr_t)(probe) + (hash)->dth_nextoffs)
418 #define DTRACE_HASHPREV(hash, probe) \
419 (dtrace_probe_t **)((uintptr_t)(probe) + (hash)->dth_prevoffs)
572 #define DTRACE_ANCHORED(probe) ((probe)->dtpr_func[0] != '\0')
628 * These functions are called from probe context. Because probe context is
631 * As a result, functions called from probe context may only call other DTrace
633 * (Note that the ASSERT macro is made probe-context safe by redefining it in
634 * terms of dtrace_assfail(), a probe-context safe function.) If arbitrary
635 * loads are to be performed from probe context, they _must_ be in terms of
638 * Some functions in this block are not actually called from probe context;
640 * "Note: not called from probe context."
669 * Atomically increment a specified error counter from probe context.
675 * Most counters stored to in probe context are per-CPU counters.
946 * structures cannot change over the duration of probe context,
1626 * the current probe to continue. Note that this routine may allow continued
1634 dtrace_probe_t *probe = ecb->dte_probe;
1635 dtrace_provider_t *prov = probe->dtpr_provider;
1644 probe->dtpr_id, probe->dtpr_arg);
1654 * see user-mode firings of this probe, call the provider's dtps_mode()
1655 * entry point to check that the probe was fired while in a user
1657 * provider to determine if we drop the probe or merely restrict
1734 * Note: not called from probe context. This function is called
1735 * asynchronously (and at a regular interval) from outside of probe context to
3060 * Note: not called from probe context. This function is called
3106 * Note: not called from probe context. This function is called
3250 * The easy case: this probe is allowed to read all of memory, so
3468 * If this is an unanchored probe, we are
3549 * Note that we are assuming that an unanchored probe is
3798 * amount of work done in probe context. As such, it is implemented as a
4906 * valid within multiple enablings of the same probe --
6908 dtrace_probe_t *probe = ecb->dte_probe;
6909 dtrace_provider_t *prov = probe->dtpr_provider;
6911 char *msg = "dtrace: breakpoint action at probe ";
6920 * It's impossible to be taking action on the NULL probe.
6922 ASSERT(probe != NULL);
6927 * the probe, along with the hex address of the ECB with the breakpoint
6938 for (str = probe->dtpr_mod; *str != '\0'; str++)
6942 for (str = probe->dtpr_func; *str != '\0'; str++)
6946 for (str = probe->dtpr_name; *str != '\0'; str++)
6973 dtrace_probe_t *probe = ecb->dte_probe;
6976 * It's impossible to be taking action on the NULL probe.
6978 ASSERT(probe != NULL);
6994 dtrace_panic("dtrace: panic action at probe %s:%s:%s:%s (ecb %p)",
6995 probe->dtpr_provider->dtpv_name, probe->dtpr_mod,
6996 probe->dtpr_func, probe->dtpr_name, (void *)ecb);
7276 * defined, we also assert that we are not recursing unless the probe ID is an
7277 * error probe.
7287 * Unless this is an ERROR probe, we are not allowed to recurse in
7288 * dtrace_probe(). Recursing into DTrace probe usually means that a
7314 * is the function called by the provider to fire a probe -- from which all
7315 * subsequent probe-context DTrace activity emanates.
7323 dtrace_probe_t *probe;
7347 probe = dtrace_probes[id - 1];
7351 if (!onintr && probe->dtpr_predcache != DTRACE_CACHEIDNONE &&
7352 probe->dtpr_predcache == curthread->t_predcache) {
7381 mstate.dtms_probe = probe;
7391 for (ecb = probe->dtpr_ecb; ecb != NULL; ecb = ecb->dte_next) {
7397 dtrace_provider_t *prov = probe->dtpr_provider;
7421 * If dtrace itself is the provider of this probe,
7441 * probe. If we are, we will only continue processing
7446 if (probe->dtpr_id == dtrace_probeid_begin &&
7458 * of this probe, call the provider's dtps_usermode()
7459 * entry point to check that the probe was fired
7465 probe->dtpr_id, probe->dtpr_arg) == 0)
7575 dtrace_cacheid_t cid = probe->dtpr_predcache;
7645 size / sizeof (pc_t), probe->dtpr_aframes,
7646 DTRACE_ANCHORED(probe) ? NULL :
7962 if (probe->dtpr_id == dtrace_probeid_error) {
7965 * error on the error probe. We bump an
8017 * sections) are not _called_ from probe context. (Any exceptions to this are
8020 * the DTrace probe hashes. (Each probe is hashed by each element of the
8021 * probe tuple -- allowing for fast lookups, regardless of what was
8086 dtrace_probe_t *probe = bucket->dthb_chain;
8088 ASSERT(probe != NULL);
8089 ndx = DTRACE_HASHSTR(hash, probe) & new_mask;
8173 dtrace_hash_remove(dtrace_hash_t *hash, dtrace_probe_t *probe)
8175 int ndx = DTRACE_HASHSTR(hash, probe) & hash->dth_mask;
8178 dtrace_probe_t **prevp = DTRACE_HASHPREV(hash, probe);
8179 dtrace_probe_t **nextp = DTRACE_HASHNEXT(hash, probe);
8182 * Find the bucket that we're removing this probe from.
8185 if (DTRACE_HASHEQ(hash, bucket->dthb_chain, probe))
8194 * The removed probe was the only probe on this
8199 ASSERT(bucket->dthb_chain == probe);
8228 * These are random utility functions that are _not_ called from probe context.
8347 * a probe tuple, or some globbed expressions for elements of a probe tuple.
8567 dtrace_probe_t template, *probe;
8575 * If the probe ID is specified in the key, just lookup by ID and
8576 * invoke the match callback once if a matching probe is found.
8579 if ((probe = dtrace_probe_lookup_id(pkp->dtpk_id)) != NULL &&
8580 dtrace_match_probe(probe, pkp, priv, uid, zoneid) > 0) {
8581 (void) (*matched)(probe, arg);
8616 * If we did not select a hash table, iterate over every probe and
8617 * invoke our callback for each one that matches our input probe key.
8621 if ((probe = dtrace_probes[i]) == NULL ||
8622 dtrace_match_probe(probe, pkp, priv, uid,
8628 if ((*matched)(probe, arg) != DTRACE_MATCH_NEXT)
8636 * If we selected a hash table, iterate over each probe of the same key
8637 * name and invoke the callback for every probe that matches the other
8638 * attributes of our input probe key.
8640 for (probe = dtrace_hash_lookup(hash, &template); probe != NULL;
8641 probe = *(DTRACE_HASHNEXT(hash, probe))) {
8643 if (dtrace_match_probe(probe, pkp, priv, uid, zoneid) <= 0)
8648 if ((*matched)(probe, arg) != DTRACE_MATCH_NEXT)
8678 * Build a probe comparison key for use with dtrace_match_probe() from the
8679 * given probe description. By convention, a null key only matches anchored
8713 * the functions in the API for probe management (found below), and
8866 dtrace_probe_t *probe, *first = NULL;
8918 if ((probe = dtrace_probes[i]) == NULL)
8921 if (probe->dtpr_provider != old)
8924 if (probe->dtpr_ecb == NULL)
8959 * remove all of them from their hash chains and from the probe array.
8962 if ((probe = dtrace_probes[i]) == NULL)
8965 if (probe->dtpr_provider != old)
8970 dtrace_hash_remove(dtrace_bymod, probe);
8971 dtrace_hash_remove(dtrace_byfunc, probe);
8972 dtrace_hash_remove(dtrace_byname, probe);
8975 first = probe;
8976 probe->dtpr_nextmod = NULL;
8978 probe->dtpr_nextmod = first;
8979 first = probe;
8985 * from the probe array. Now issue a dtrace_sync() to be sure that
8986 * everyone has cleared out from any probe array processing.
8990 for (probe = first; probe != NULL; probe = first) {
8991 first = probe->dtpr_nextmod;
8993 old->dtpv_pops.dtps_destroy(old->dtpv_arg, probe->dtpr_id,
8994 probe->dtpr_arg);
8995 kmem_free(probe->dtpr_mod, strlen(probe->dtpr_mod) + 1);
8996 kmem_free(probe->dtpr_func, strlen(probe->dtpr_func) + 1);
8997 kmem_free(probe->dtpr_name, strlen(probe->dtpr_name) + 1);
8999 vmem_free(dtrace_arena, (void *)(uintptr_t)(probe->dtpr_id), 1);
9001 free_unr(dtrace_arena, probe->dtpr_id);
9003 kmem_free(probe, sizeof (dtrace_probe_t));
9039 * Invalidate the specified provider. All subsequent probe lookups for the
9083 dtrace_probe_t *probe;
9098 if ((probe = dtrace_probes[i]) == NULL)
9101 if (probe->dtpr_provider != prov)
9104 if (probe->dtpr_ecb != NULL)
9109 dtrace_hash_remove(dtrace_bymod, probe);
9110 dtrace_hash_remove(dtrace_byfunc, probe);
9111 dtrace_hash_remove(dtrace_byname, probe);
9114 probe->dtpr_arg);
9115 kmem_free(probe->dtpr_mod, strlen(probe->dtpr_mod) + 1);
9116 kmem_free(probe->dtpr_func, strlen(probe->dtpr_func) + 1);
9117 kmem_free(probe->dtpr_name, strlen(probe->dtpr_name) + 1);
9118 kmem_free(probe, sizeof (dtrace_probe_t));
9135 * The functions in this section perform the DTrace probe management,
9143 * Create a probe with the specified module name, function name, and name.
9149 dtrace_probe_t *probe, **probes;
9165 probe = kmem_zalloc(sizeof (dtrace_probe_t), KM_SLEEP);
9167 probe->dtpr_id = id;
9168 probe->dtpr_gen = dtrace_probegen++;
9169 probe->dtpr_mod = dtrace_strdup(mod);
9170 probe->dtpr_func = dtrace_strdup(func);
9171 probe->dtpr_name = dtrace_strdup(name);
9172 probe->dtpr_arg = arg;
9173 probe->dtpr_aframes = aframes;
9174 probe->dtpr_provider = provider;
9176 dtrace_hash_add(dtrace_bymod, probe);
9177 dtrace_hash_add(dtrace_byfunc, probe);
9178 dtrace_hash_add(dtrace_byname, probe);
9217 dtrace_probes[id - 1] = probe;
9237 dtrace_probe_lookup_match(dtrace_probe_t *probe, void *arg)
9239 *((dtrace_id_t *)arg) = probe->dtpr_id;
9245 * Look up a probe based on provider and one or more of module name, function
9246 * name and probe name.
9276 * Returns the probe argument associated with the specified probe.
9281 dtrace_probe_t *probe;
9286 if ((probe = dtrace_probe_lookup_id(pid)) != NULL &&
9287 probe->dtpr_provider == (dtrace_provider_t *)id)
9288 rval = probe->dtpr_arg;
9296 * Copy a probe into a probe description.
9313 * Called to indicate that a probe -- or probes -- should be provided by a
9318 * opportunity to dynamically provide the specified probe, allowing providers
9373 * Iterate over each probe, and call the Framework-to-Provider API function
9381 dtrace_probe_t *probe;
9386 * We disable interrupts to walk through the probe array. This is
9393 if ((probe = dtrace_probes[i]) == NULL)
9396 if (probe->dtpr_ecb == NULL) {
9398 * This probe isn't enabled -- don't call the function.
9403 prov = probe->dtpr_provider;
9407 func(prov->dtpv_arg, i + 1, probe->dtpr_arg);
9428 * create an ECB with a NULL probe.
9477 dof_probe_t *probe;
9529 probe = (dof_probe_t *)(uintptr_t)(daddr +
9533 if (strlen(strtab + probe->dofpr_func) >= DTRACE_FUNCNAMELEN)
9537 dhpb.dthpb_func = strtab + probe->dofpr_func;
9538 dhpb.dthpb_name = strtab + probe->dofpr_name;
9539 dhpb.dthpb_base = probe->dofpr_addr;
9540 dhpb.dthpb_offs = off + probe->dofpr_offidx;
9541 dhpb.dthpb_noffs = probe->dofpr_noffs;
9543 dhpb.dthpb_enoffs = enoff + probe->dofpr_enoffidx;
9544 dhpb.dthpb_nenoffs = probe->dofpr_nenoffs;
9549 dhpb.dthpb_args = arg + probe->dofpr_argidx;
9550 dhpb.dthpb_nargc = probe->dofpr_nargc;
9551 dhpb.dthpb_xargc = probe->dofpr_xargc;
9552 dhpb.dthpb_ntypes = strtab + probe->dofpr_nargv;
9553 dhpb.dthpb_xtypes = strtab + probe->dofpr_xargv;
11089 dtrace_ecb_add(dtrace_state_t *state, dtrace_probe_t *probe)
11098 ecb->dte_probe = probe;
11158 dtrace_probe_t *probe = ecb->dte_probe;
11164 if (probe == NULL) {
11166 * This is the NULL probe -- there's nothing to do.
11171 if (probe->dtpr_ecb == NULL) {
11172 dtrace_provider_t *prov = probe->dtpr_provider;
11175 * We're the first ECB on this probe.
11177 probe->dtpr_ecb = probe->dtpr_ecb_last = ecb;
11180 probe->dtpr_predcache = ecb->dte_predicate->dtp_cacheid;
11183 probe->dtpr_id, probe->dtpr_arg);
11186 * This probe is already active. Swing the last pointer to
11190 ASSERT(probe->dtpr_ecb_last != NULL);
11191 probe->dtpr_ecb_last->dte_next = ecb;
11192 probe->dtpr_ecb_last = ecb;
11193 probe->dtpr_predcache = 0;
11795 * We disable the ECB by removing it from its probe.
11798 dtrace_probe_t *probe = ecb->dte_probe;
11802 if (probe == NULL) {
11804 * This is the NULL probe; there is nothing to disable.
11809 for (pecb = probe->dtpr_ecb; pecb != NULL; pecb = pecb->dte_next) {
11818 probe->dtpr_ecb = ecb->dte_next;
11823 if (ecb == probe->dtpr_ecb_last) {
11825 probe->dtpr_ecb_last = prev;
11829 * The ECB has been disconnected from the probe; now sync to assure
11834 if (probe->dtpr_ecb == NULL) {
11836 * That was the last ECB on the probe; clear the predicate
11837 * cache ID for the probe, disable it and sync one more time
11840 dtrace_provider_t *prov = probe->dtpr_provider;
11843 ASSERT(probe->dtpr_ecb_last == NULL);
11844 probe->dtpr_predcache = DTRACE_CACHEIDNONE;
11846 probe->dtpr_id, probe->dtpr_arg);
11850 * There is at least one ECB remaining on the probe. If there
11851 * is _exactly_ one, set the probe's predicate cache ID to be
11854 ASSERT(probe->dtpr_ecb_last != NULL);
11855 ASSERT(probe->dtpr_predcache == DTRACE_CACHEIDNONE);
11857 if (probe->dtpr_ecb == probe->dtpr_ecb_last) {
11858 dtrace_predicate_t *p = probe->dtpr_ecb->dte_predicate;
11860 ASSERT(probe->dtpr_ecb->dte_next == NULL);
11863 probe->dtpr_predcache = p->dtp_cacheid;
11894 dtrace_ecb_create(dtrace_state_t *state, dtrace_probe_t *probe,
11906 ecb = dtrace_ecb_add(state, probe);
11914 if (probe != NULL) {
11924 * and DTRACE_COND_ZONEOWNER will then do at probe time.
11926 prov = probe->dtpr_provider;
11982 dtrace_ecb_create_enable(dtrace_probe_t *probe, void *arg)
11990 if (probe != NULL && probe->dtpr_gen < enab->dten_probegen) {
11992 * This probe was created in a generation for which this
11999 if ((ecb = dtrace_ecb_create(state, probe, enab)) == NULL)
12099 * that processes the BEGIN probe has its buffer activated
12300 * Note: called from probe context. This function just increments the drop
12313 * Note: called from probe context. This function is called to reserve space
12447 * the previous failed probe attempt. But at
12600 * if an ECB on a defunct probe (but for an active enabling) can be safely
12715 * specified ECB in every way, but has the specified probe description.
12742 printf("dtrace: enabling probe %d (%s:%s:%s:%s)\n", i,
12746 cmn_err(CE_NOTE, "enabling probe %d (%s:%s:%s:%s)", i,
12881 * Now iterate over each probe description; we're looking for
12882 * an exact match to the specified probe description.
12901 * We have a winning probe! Add it to our growing
13034 * NULL probe -- which is exactly what this function does.
13124 dtrace_probe_t *probe;
13133 if ((probe = dtrace_probes[i]) == NULL)
13136 if (probe->dtpr_ecb == NULL)
13139 prov = probe->dtpr_provider;
13168 * associated with the probe, we quit trying -- reaping is only
13172 while ((ecb = probe->dtpr_ecb) != NULL) {
13187 ASSERT(probe->dtpr_ecb != ecb);
13565 dof_probedesc_t *probe;
13572 dtrace_dof_error(dof, "invalid probe section");
13577 dtrace_dof_error(dof, "bad alignment in probe description");
13582 dtrace_dof_error(dof, "truncated probe description");
13586 probe = (dof_probedesc_t *)(uintptr_t)(daddr + sec->dofs_offset);
13587 strtab = dtrace_dof_sect(dof, DOF_SECT_STRTAB, probe->dofp_strtab);
13595 if (probe->dofp_provider >= strtab->dofs_size) {
13596 dtrace_dof_error(dof, "corrupt probe provider");
13601 (char *)(str + probe->dofp_provider),
13602 MIN(DTRACE_PROVNAMELEN - 1, size - probe->dofp_provider));
13604 if (probe->dofp_mod >= strtab->dofs_size) {
13605 dtrace_dof_error(dof, "corrupt probe module");
13609 (void) strncpy(desc->dtpd_mod, (char *)(str + probe->dofp_mod),
13610 MIN(DTRACE_MODNAMELEN - 1, size - probe->dofp_mod));
13612 if (probe->dofp_func >= strtab->dofs_size) {
13613 dtrace_dof_error(dof, "corrupt probe function");
13617 (void) strncpy(desc->dtpd_func, (char *)(str + probe->dofp_func),
13618 MIN(DTRACE_FUNCNAMELEN - 1, size - probe->dofp_func));
13620 if (probe->dofp_name >= strtab->dofs_size) {
13621 dtrace_dof_error(dof, "corrupt probe name");
13625 (void) strncpy(desc->dtpd_name, (char *)(str + probe->dofp_name),
13626 MIN(DTRACE_NAMELEN - 1, size - probe->dofp_name));
14705 * Depending on the user credentials, we set flag bits which alter probe
14719 * examine the credential and the zone from probe context.
14934 dtrace_probe_t *probe;
14945 probe = dtrace_probes[dtrace_probeid_end - 1];
14946 ASSERT(probe != NULL);
14948 for (ecb = probe->dtpr_ecb; ecb != NULL; ecb = ecb->dte_next) {
15192 * Now it's time to actually fire the BEGIN probe. We need to disable
15194 * probe (the data from this CPU will be processed first at user
15206 * We may have had an exit action from a BEGIN probe; only change our
15231 * processing an ECB halfway down a probe's ECB chain; all CPUs will
15296 * iff we're in the END probe.
15303 * Finally, we can release the reserve and call the END probe. We
15304 * disable interrupts across calling the END probe to allow us to
15305 * return the CPU on which we actually called the END probe. This
15428 * issue a sync to be sure that everyone is out of probe
15454 dtrace_probe_t *probe = ecb->dte_probe;
15455 dtrace_provider_t *prov = probe->dtpr_provider;
15471 * every CPU is out of probe context.
16162 dof_probe_t *probe;
16248 probe = (dof_probe_t *)(uintptr_t)(daddr +
16251 if (probe->dofpr_func >= str_sec->dofs_size) {
16256 if (strlen(strtab + probe->dofpr_func) >= DTRACE_FUNCNAMELEN) {
16260 * Unlike provider and probe names, we cannot reasonably
16263 * skip this probe in dtrace_helper_provide_one().
16267 if (probe->dofpr_name >= str_sec->dofs_size ||
16268 strlen(strtab + probe->dofpr_name) >= DTRACE_NAMELEN) {
16269 dtrace_dof_error(dof, "invalid probe name");
16277 if (probe->dofpr_offidx + probe->dofpr_noffs <
16278 probe->dofpr_offidx ||
16279 (probe->dofpr_offidx + probe->dofpr_noffs) *
16281 dtrace_dof_error(dof, "invalid probe offset");
16289 * perform the same checks as for probe offsets
16293 if (probe->dofpr_enoffidx != 0 ||
16294 probe->dofpr_nenoffs != 0) {
16299 } else if (probe->dofpr_enoffidx +
16300 probe->dofpr_nenoffs < probe->dofpr_enoffidx ||
16301 (probe->dofpr_enoffidx + probe->dofpr_nenoffs) *
16308 if (probe->dofpr_noffs + probe->dofpr_nenoffs == 0) {
16309 dtrace_dof_error(dof, "zero probe and "
16313 } else if (probe->dofpr_noffs == 0) {
16314 dtrace_dof_error(dof, "zero probe offsets");
16318 if (probe->dofpr_argidx + probe->dofpr_xargc <
16319 probe->dofpr_argidx ||
16320 (probe->dofpr_argidx + probe->dofpr_xargc) *
16326 typeidx = probe->dofpr_nargv;
16327 typestr = strtab + probe->dofpr_nargv;
16328 for (k = 0; k < probe->dofpr_nargc; k++) {
16345 typeidx = probe->dofpr_xargv;
16346 typestr = strtab + probe->dofpr_xargv;
16347 for (k = 0; k < probe->dofpr_xargc; k++) {
16348 if (arg[probe->dofpr_argidx + k] > probe->dofpr_nargc) {
16747 dtrace_probe_t template, *probe, *first, *next;
16773 /* Don't allow unloads if a probe is enabled. */
16796 for (probe = first = dtrace_hash_lookup(dtrace_bymod, &template);
16797 probe != NULL; probe = probe->dtpr_nextmod) {
16798 if (probe->dtpr_ecb != NULL) {
16807 * unloading a module that has an enabled probe in it.
16813 * probe, either.
16829 probe = first;
16831 for (first = NULL; probe != NULL; probe = next) {
16832 ASSERT(dtrace_probes[probe->dtpr_id - 1] == probe);
16834 dtrace_probes[probe->dtpr_id - 1] = NULL;
16836 next = probe->dtpr_nextmod;
16837 dtrace_hash_remove(dtrace_bymod, probe);
16838 dtrace_hash_remove(dtrace_byfunc, probe);
16839 dtrace_hash_remove(dtrace_byname, probe);
16842 first = probe;
16843 probe->dtpr_nextmod = NULL;
16845 probe->dtpr_nextmod = first;
16846 first = probe;
16852 * from the probe array. Now issue a dtrace_sync() to be sure that
16853 * everyone has cleared out from any probe array processing.
16857 for (probe = first; probe != NULL; probe = first) {
16858 first = probe->dtpr_nextmod;
16859 prov = probe->dtpr_provider;
16860 prov->dtpv_pops.dtps_destroy(prov->dtpv_arg, probe->dtpr_id,
16861 probe->dtpr_arg);
16862 kmem_free(probe->dtpr_mod, strlen(probe->dtpr_mod) + 1);
16863 kmem_free(probe->dtpr_func, strlen(probe->dtpr_func) + 1);
16864 kmem_free(probe->dtpr_name, strlen(probe->dtpr_name) + 1);
16866 vmem_free(dtrace_arena, (void *)(uintptr_t)probe->dtpr_id, 1);
16868 free_unr(dtrace_arena, probe->dtpr_id);
16870 kmem_free(probe, sizeof (dtrace_probe_t));
17027 * in probe context -- that assures that a dtrace_sync() can be used
17344 * CPU is in probe context with enabled helper tracing
17755 dtrace_probe_t *probe = NULL;
17773 * Before we attempt to match this probe, we want to give
17794 if ((probe = dtrace_probes[i - 1]) != NULL &&
17795 (m = dtrace_match_probe(probe, &pkey,
17807 if ((probe = dtrace_probes[i - 1]) != NULL &&
17808 dtrace_match_priv(probe, priv, uid, zoneid))
17813 if (probe == NULL) {
17818 dtrace_probe_description(probe, &desc);
17829 dtrace_probe_t *probe;
17852 if ((probe = dtrace_probes[desc.dtargd_id - 1]) == NULL) {
17861 prov = probe->dtpr_provider;
17865 * There isn't any typed information for this probe.
17875 probe->dtpr_id, probe->dtpr_arg, &desc);
18371 nulldev, /* probe */