Lines Matching defs:probe
47 * - Non-probe context utility functions
167 static vmem_t *dtrace_arena; /* probe ID arena */
189 static dtrace_genid_t dtrace_probegen; /* current probe generation */
202 * etc. Importantly, dtrace_lock is _not_ required when in probe context;
203 * probe context is lock-free -- synchronization is handled via the
226 static kmutex_t dtrace_lock; /* probe state lock */
280 static dtrace_id_t dtrace_probeid_begin; /* special BEGIN probe */
281 static dtrace_id_t dtrace_probeid_end; /* special END probe */
282 dtrace_id_t dtrace_probeid_error; /* special ERROR probe */
327 #define DTRACE_HASHSTR(hash, probe) \
328 dtrace_hash_str(*((char **)((uintptr_t)(probe) + (hash)->dth_stroffs)))
330 #define DTRACE_HASHNEXT(hash, probe) \
331 (dtrace_probe_t **)((uintptr_t)(probe) + (hash)->dth_nextoffs)
333 #define DTRACE_HASHPREV(hash, probe) \
334 (dtrace_probe_t **)((uintptr_t)(probe) + (hash)->dth_prevoffs)
470 #define DTRACE_ANCHORED(probe) ((probe)->dtpr_func[0] != '\0')
517 * These functions are called from probe context. Because probe context is
520 * As a result, functions called from probe context may only call other DTrace
522 * (Note that the ASSERT macro is made probe-context safe by redefining it in
523 * terms of dtrace_assfail(), a probe-context safe function.) If arbitrary
524 * loads are to be performed from probe context, they _must_ be in terms of
527 * Some functions in this block are not actually called from probe context;
529 * "Note: not called from probe context."
554 * Atomically increment a specified error counter from probe context.
560 * Most counters stored to in probe context are per-CPU counters.
831 * structures cannot change over the duration of probe context,
1509 * the current probe to continue. Note that this routine may allow continued
1517 dtrace_probe_t *probe = ecb->dte_probe;
1518 dtrace_provider_t *prov = probe->dtpr_provider;
1526 probe->dtpr_id, probe->dtpr_arg);
1535 * see user-mode firings of this probe, check that the probe was fired
1537 * specified by the provider to determine if we drop the probe or
1618 * Note: not called from probe context. This function is called
1619 * asynchronously (and at a regular interval) from outside of probe context to
2944 * Note: not called from probe context. This function is called
2990 * Note: not called from probe context. This function is called
3134 * The easy case: this probe is allowed to read all of memory, so
3328 * If this is an unanchored probe, we are
3408 * Note that we are assuming that an unanchored probe is
3638 * amount of work done in probe context. As such, it is implemented as a
4637 * valid within multiple enablings of the same probe --
6571 dtrace_probe_t *probe = ecb->dte_probe;
6572 dtrace_provider_t *prov = probe->dtpr_provider;
6574 char *msg = "dtrace: breakpoint action at probe ";
6584 * It's impossible to be taking action on the NULL probe.
6586 ASSERT(probe != NULL);
6591 * the probe, along with the hex address of the ECB with the breakpoint
6602 for (str = probe->dtpr_mod; *str != '\0'; str++)
6606 for (str = probe->dtpr_func; *str != '\0'; str++)
6610 for (str = probe->dtpr_name; *str != '\0'; str++)
6633 dtrace_probe_t *probe = ecb->dte_probe;
6636 * It's impossible to be taking action on the NULL probe.
6638 ASSERT(probe != NULL);
6654 dtrace_panic("dtrace: panic action at probe %s:%s:%s:%s (ecb %p)",
6655 probe->dtpr_provider->dtpv_name, probe->dtpr_mod,
6656 probe->dtpr_func, probe->dtpr_name, (void *)ecb);
6918 * is the function called by the provider to fire a probe -- from which all
6919 * subsequent probe-context DTrace activity emanates.
6927 dtrace_probe_t *probe;
6948 * Also refuse to process any probe firings that might happen on a
6956 probe = dtrace_probes[id - 1];
6962 if (!onintr && probe->dtpr_predcache != DTRACE_CACHEIDNONE &&
6963 probe->dtpr_predcache == curthread->t_predcache) {
6987 mstate.dtms_probe = probe;
6997 for (ecb = probe->dtpr_ecb; ecb != NULL; ecb = ecb->dte_next) {
7003 dtrace_provider_t *prov = probe->dtpr_provider;
7032 * If dtrace itself is the provider of this probe,
7052 * probe. If we are, we will only continue processing
7057 if (probe->dtpr_id == dtrace_probeid_begin &&
7125 dtrace_cacheid_t cid = probe->dtpr_predcache;
7196 size / sizeof (pc_t), probe->dtpr_aframes,
7197 DTRACE_ANCHORED(probe) ? NULL :
7474 if (probe->dtpr_id == dtrace_probeid_error) {
7477 * error on the error probe. We bump an
7532 * sections) are not _called_ from probe context. (Any exceptions to this are
7535 * the DTrace probe hashes. (Each probe is hashed by each element of the
7536 * probe tuple -- allowing for fast lookups, regardless of what was
7601 dtrace_probe_t *probe = bucket->dthb_chain;
7603 ASSERT(probe != NULL);
7604 ndx = DTRACE_HASHSTR(hash, probe) & new_mask;
7688 dtrace_hash_remove(dtrace_hash_t *hash, dtrace_probe_t *probe)
7690 int ndx = DTRACE_HASHSTR(hash, probe) & hash->dth_mask;
7693 dtrace_probe_t **prevp = DTRACE_HASHPREV(hash, probe);
7694 dtrace_probe_t **nextp = DTRACE_HASHNEXT(hash, probe);
7697 * Find the bucket that we're removing this probe from.
7700 if (DTRACE_HASHEQ(hash, bucket->dthb_chain, probe))
7709 * The removed probe was the only probe on this
7714 ASSERT(bucket->dthb_chain == probe);
7743 * These are random utility functions that are _not_ called from probe context.
7858 * a probe tuple, or some globbed expressions for elements of a probe tuple.
8078 dtrace_probe_t template, *probe;
8086 * If the probe ID is specified in the key, just lookup by ID and
8087 * invoke the match callback once if a matching probe is found.
8090 if ((probe = dtrace_probe_lookup_id(pkp->dtpk_id)) != NULL &&
8091 dtrace_match_probe(probe, pkp, priv, uid, zoneid) > 0) {
8092 if ((*matched)(probe, arg) == DTRACE_MATCH_FAIL)
8128 * If we did not select a hash table, iterate over every probe and
8129 * invoke our callback for each one that matches our input probe key.
8133 if ((probe = dtrace_probes[i]) == NULL ||
8134 dtrace_match_probe(probe, pkp, priv, uid,
8140 if ((rc = (*matched)(probe, arg)) !=
8152 * If we selected a hash table, iterate over each probe of the same key
8153 * name and invoke the callback for every probe that matches the other
8154 * attributes of our input probe key.
8156 for (probe = dtrace_hash_lookup(hash, &template); probe != NULL;
8157 probe = *(DTRACE_HASHNEXT(hash, probe))) {
8159 if (dtrace_match_probe(probe, pkp, priv, uid, zoneid) <= 0)
8164 if ((rc = (*matched)(probe, arg)) != DTRACE_MATCH_NEXT) {
8197 * Build a probe comparison key for use with dtrace_match_probe() from the
8198 * given probe description. By convention, a null key only matches anchored
8232 * the functions in the API for probe management (found below), and
8381 dtrace_probe_t *probe, *first = NULL;
8426 if ((probe = dtrace_probes[i]) == NULL)
8429 if (probe->dtpr_provider != old)
8432 if (probe->dtpr_ecb == NULL)
8465 * remove all of them from their hash chains and from the probe array.
8468 if ((probe = dtrace_probes[i]) == NULL)
8471 if (probe->dtpr_provider != old)
8476 dtrace_hash_remove(dtrace_bymod, probe);
8477 dtrace_hash_remove(dtrace_byfunc, probe);
8478 dtrace_hash_remove(dtrace_byname, probe);
8481 first = probe;
8482 probe->dtpr_nextmod = NULL;
8484 probe->dtpr_nextmod = first;
8485 first = probe;
8491 * from the probe array. Now issue a dtrace_sync() to be sure that
8492 * everyone has cleared out from any probe array processing.
8496 for (probe = first; probe != NULL; probe = first) {
8497 first = probe->dtpr_nextmod;
8499 old->dtpv_pops.dtps_destroy(old->dtpv_arg, probe->dtpr_id,
8500 probe->dtpr_arg);
8501 kmem_free(probe->dtpr_mod, strlen(probe->dtpr_mod) + 1);
8502 kmem_free(probe->dtpr_func, strlen(probe->dtpr_func) + 1);
8503 kmem_free(probe->dtpr_name, strlen(probe->dtpr_name) + 1);
8504 vmem_free(dtrace_arena, (void *)(uintptr_t)(probe->dtpr_id), 1);
8505 kmem_free(probe, sizeof (dtrace_probe_t));
8537 * Invalidate the specified provider. All subsequent probe lookups for the
8580 dtrace_probe_t *probe;
8594 if ((probe = dtrace_probes[i]) == NULL)
8597 if (probe->dtpr_provider != prov)
8600 if (probe->dtpr_ecb != NULL)
8605 dtrace_hash_remove(dtrace_bymod, probe);
8606 dtrace_hash_remove(dtrace_byfunc, probe);
8607 dtrace_hash_remove(dtrace_byname, probe);
8610 probe->dtpr_arg);
8611 kmem_free(probe->dtpr_mod, strlen(probe->dtpr_mod) + 1);
8612 kmem_free(probe->dtpr_func, strlen(probe->dtpr_func) + 1);
8613 kmem_free(probe->dtpr_name, strlen(probe->dtpr_name) + 1);
8614 kmem_free(probe, sizeof (dtrace_probe_t));
8627 * The functions in this section perform the DTrace probe management,
8635 * Create a probe with the specified module name, function name, and name.
8641 dtrace_probe_t *probe, **probes;
8653 probe = kmem_zalloc(sizeof (dtrace_probe_t), KM_SLEEP);
8655 probe->dtpr_id = id;
8656 probe->dtpr_gen = dtrace_probegen++;
8657 probe->dtpr_mod = dtrace_strdup(mod);
8658 probe->dtpr_func = dtrace_strdup(func);
8659 probe->dtpr_name = dtrace_strdup(name);
8660 probe->dtpr_arg = arg;
8661 probe->dtpr_aframes = aframes;
8662 probe->dtpr_provider = provider;
8664 dtrace_hash_add(dtrace_bymod, probe);
8665 dtrace_hash_add(dtrace_byfunc, probe);
8666 dtrace_hash_add(dtrace_byname, probe);
8705 dtrace_probes[id - 1] = probe;
8725 dtrace_probe_lookup_match(dtrace_probe_t *probe, void *arg)
8727 *((dtrace_id_t *)arg) = probe->dtpr_id;
8733 * Look up a probe based on provider and one or more of module name, function
8734 * name and probe name.
8764 * Returns the probe argument associated with the specified probe.
8769 dtrace_probe_t *probe;
8774 if ((probe = dtrace_probe_lookup_id(pid)) != NULL &&
8775 probe->dtpr_provider == (dtrace_provider_t *)id)
8776 rval = probe->dtpr_arg;
8784 * Copy a probe into a probe description.
8801 * Called to indicate that a probe -- or probes -- should be provided by a
8806 * opportunity to dynamically provide the specified probe, allowing providers
8856 * Iterate over each probe, and call the Framework-to-Provider API function
8864 dtrace_probe_t *probe;
8869 * We disable interrupts to walk through the probe array. This is
8876 if ((probe = dtrace_probes[i]) == NULL)
8879 if (probe->dtpr_ecb == NULL) {
8881 * This probe isn't enabled -- don't call the function.
8886 prov = probe->dtpr_provider;
8890 func(prov->dtpv_arg, i + 1, probe->dtpr_arg);
8910 * create an ECB with a NULL probe.
8959 dof_probe_t *probe;
9011 probe = (dof_probe_t *)(uintptr_t)(daddr +
9015 dhpb.dthpb_func = strtab + probe->dofpr_func;
9016 dhpb.dthpb_name = strtab + probe->dofpr_name;
9017 dhpb.dthpb_base = probe->dofpr_addr;
9018 dhpb.dthpb_offs = off + probe->dofpr_offidx;
9019 dhpb.dthpb_noffs = probe->dofpr_noffs;
9021 dhpb.dthpb_enoffs = enoff + probe->dofpr_enoffidx;
9022 dhpb.dthpb_nenoffs = probe->dofpr_nenoffs;
9027 dhpb.dthpb_args = arg + probe->dofpr_argidx;
9028 dhpb.dthpb_nargc = probe->dofpr_nargc;
9029 dhpb.dthpb_xargc = probe->dofpr_xargc;
9030 dhpb.dthpb_ntypes = strtab + probe->dofpr_nargv;
9031 dhpb.dthpb_xtypes = strtab + probe->dofpr_xargv;
10567 dtrace_ecb_add(dtrace_state_t *state, dtrace_probe_t *probe)
10576 ecb->dte_probe = probe;
10636 dtrace_probe_t *probe = ecb->dte_probe;
10642 if (probe == NULL) {
10644 * This is the NULL probe -- there's nothing to do.
10649 if (probe->dtpr_ecb == NULL) {
10650 dtrace_provider_t *prov = probe->dtpr_provider;
10653 * We're the first ECB on this probe.
10655 probe->dtpr_ecb = probe->dtpr_ecb_last = ecb;
10658 probe->dtpr_predcache = ecb->dte_predicate->dtp_cacheid;
10661 probe->dtpr_id, probe->dtpr_arg));
10664 * This probe is already active. Swing the last pointer to
10669 ASSERT(probe->dtpr_ecb_last != NULL);
10670 probe->dtpr_ecb_last->dte_next = ecb;
10671 probe->dtpr_ecb_last = ecb;
10672 probe->dtpr_predcache = DTRACE_CACHEIDNONE;
11259 * We disable the ECB by removing it from its probe.
11262 dtrace_probe_t *probe = ecb->dte_probe;
11266 if (probe == NULL) {
11268 * This is the NULL probe; there is nothing to disable.
11273 for (pecb = probe->dtpr_ecb; pecb != NULL; pecb = pecb->dte_next) {
11290 probe->dtpr_ecb = ecb->dte_next;
11295 if (ecb == probe->dtpr_ecb_last) {
11297 probe->dtpr_ecb_last = prev;
11300 if (probe->dtpr_ecb == NULL) {
11302 * That was the last ECB on the probe; clear the predicate
11303 * cache ID for the probe and disable it.
11305 dtrace_provider_t *prov = probe->dtpr_provider;
11308 ASSERT(probe->dtpr_ecb_last == NULL);
11309 probe->dtpr_predcache = DTRACE_CACHEIDNONE;
11311 probe->dtpr_id, probe->dtpr_arg);
11314 * There is at least one ECB remaining on the probe. If there
11315 * is _exactly_ one, set the probe's predicate cache ID to be
11318 ASSERT(probe->dtpr_ecb_last != NULL);
11319 ASSERT(probe->dtpr_predcache == DTRACE_CACHEIDNONE);
11321 if (probe->dtpr_ecb == probe->dtpr_ecb_last) {
11322 dtrace_predicate_t *p = probe->dtpr_ecb->dte_predicate;
11324 ASSERT(probe->dtpr_ecb->dte_next == NULL);
11327 probe->dtpr_predcache = p->dtp_cacheid;
11363 dtrace_ecb_create(dtrace_state_t *state, dtrace_probe_t *probe,
11375 ecb = dtrace_ecb_add(state, probe);
11383 if (probe != NULL) {
11393 * and DTRACE_COND_ZONEOWNER will then do at probe time.
11395 prov = probe->dtpr_provider;
11451 dtrace_ecb_create_enable(dtrace_probe_t *probe, void *arg)
11459 if (probe != NULL && probe->dtpr_gen < enab->dten_probegen) {
11461 * This probe was created in a generation for which this
11468 if ((ecb = dtrace_ecb_create(state, probe, enab)) == NULL)
11472 * If we can, we want to defer actually enabling the probe until
11475 * allocation), and for enablings with a heavy probe effect (e.g.,
11476 * enabling every FBT probe), that work can become debilitatingly slow
11485 * (2) If the probe is provided by DTrace itself, we choose to enable
11490 (probe != NULL && probe->dtpr_provider == dtrace_provider)) {
11599 * that processes the BEGIN probe has its buffer activated
11699 * Note: called from probe context. This function just increments the drop
11712 * Note: called from probe context. This function is called to reserve space
11846 * the previous failed probe attempt. But at
11999 * if an ECB on a defunct probe (but for an active enabling) can be safely
12113 * specified ECB in every way, but has the specified probe description.
12139 cmn_err(CE_NOTE, "enabling probe %d (%s:%s:%s:%s)", i,
12272 * Now iterate over each probe description; we're looking for
12273 * an exact match to the specified probe description.
12292 * We have a winning probe! Add it to our growing
12353 * If a provider failed to enable a probe then get out and
12432 * NULL probe -- which is exactly what this function does.
12522 dtrace_probe_t *probe;
12531 if ((probe = dtrace_probes[i]) == NULL)
12534 if (probe->dtpr_ecb == NULL)
12537 prov = probe->dtpr_provider;
12566 * associated with the probe, we quit trying -- reaping is only
12570 while ((ecb = probe->dtpr_ecb) != NULL) {
12585 ASSERT(probe->dtpr_ecb != ecb);
12806 dof_probedesc_t *probe;
12813 dtrace_dof_error(dof, "invalid probe section");
12818 dtrace_dof_error(dof, "bad alignment in probe description");
12823 dtrace_dof_error(dof, "truncated probe description");
12827 probe = (dof_probedesc_t *)(uintptr_t)(daddr + sec->dofs_offset);
12828 strtab = dtrace_dof_sect(dof, DOF_SECT_STRTAB, probe->dofp_strtab);
12836 if (probe->dofp_provider >= strtab->dofs_size) {
12837 dtrace_dof_error(dof, "corrupt probe provider");
12842 (char *)(str + probe->dofp_provider),
12843 MIN(DTRACE_PROVNAMELEN - 1, size - probe->dofp_provider));
12845 if (probe->dofp_mod >= strtab->dofs_size) {
12846 dtrace_dof_error(dof, "corrupt probe module");
12850 (void) strncpy(desc->dtpd_mod, (char *)(str + probe->dofp_mod),
12851 MIN(DTRACE_MODNAMELEN - 1, size - probe->dofp_mod));
12853 if (probe->dofp_func >= strtab->dofs_size) {
12854 dtrace_dof_error(dof, "corrupt probe function");
12858 (void) strncpy(desc->dtpd_func, (char *)(str + probe->dofp_func),
12859 MIN(DTRACE_FUNCNAMELEN - 1, size - probe->dofp_func));
12861 if (probe->dofp_name >= strtab->dofs_size) {
12862 dtrace_dof_error(dof, "corrupt probe name");
12866 (void) strncpy(desc->dtpd_name, (char *)(str + probe->dofp_name),
12867 MIN(DTRACE_NAMELEN - 1, size - probe->dofp_name));
13813 * other hand, it saves an additional memory reference in the probe
13847 * Depending on the user credentials, we set flag bits which alter probe
13861 * examine the credential and the zone from probe context.
14072 dtrace_probe_t *probe;
14083 probe = dtrace_probes[dtrace_probeid_end - 1];
14084 ASSERT(probe != NULL);
14086 for (ecb = probe->dtpr_ecb; ecb != NULL; ecb = ecb->dte_next) {
14277 dtrace_probe_t *probe;
14283 * Any ECB on a DTrace-provided probe has already been
14286 if ((probe = ecb->dte_probe) != NULL &&
14287 probe->dtpr_provider == dtrace_provider) {
14294 * enable the probe, disable all of the ECBs that we
14304 * to a DTrace-provided probe...
14306 if ((probe = ecb->dte_probe) != NULL &&
14307 probe->dtpr_provider == dtrace_provider) {
14375 * Now it's time to actually fire the BEGIN probe. We need to disable
14377 * probe (the data from this CPU will be processed first at user
14389 * We may have had an exit action from a BEGIN probe; only change our
14402 * processing an ECB halfway down a probe's ECB chain; all CPUs will
14466 * iff we're in the END probe.
14473 * Finally, we can release the reserve and call the END probe. We
14474 * disable interrupts across calling the END probe to allow us to
14475 * return the CPU on which we actually called the END probe. This
14593 * issue a sync to be sure that everyone is out of probe
14609 * going to result in more work: the enabled probe effect of kernel
14638 dtrace_probe_t *probe = ecb->dte_probe;
14639 dtrace_provider_t *prov = probe->dtpr_provider;
14656 * every CPU is out of probe context.
15329 dof_probe_t *probe;
15415 probe = (dof_probe_t *)(uintptr_t)(daddr +
15418 if (probe->dofpr_func >= str_sec->dofs_size) {
15423 if (strlen(strtab + probe->dofpr_func) >= DTRACE_FUNCNAMELEN) {
15428 if (probe->dofpr_name >= str_sec->dofs_size ||
15429 strlen(strtab + probe->dofpr_name) >= DTRACE_NAMELEN) {
15430 dtrace_dof_error(dof, "invalid probe name");
15438 if (probe->dofpr_offidx + probe->dofpr_noffs <
15439 probe->dofpr_offidx ||
15440 (probe->dofpr_offidx + probe->dofpr_noffs) *
15442 dtrace_dof_error(dof, "invalid probe offset");
15450 * perform the same checks as for probe offsets
15454 if (probe->dofpr_enoffidx != 0 ||
15455 probe->dofpr_nenoffs != 0) {
15460 } else if (probe->dofpr_enoffidx +
15461 probe->dofpr_nenoffs < probe->dofpr_enoffidx ||
15462 (probe->dofpr_enoffidx + probe->dofpr_nenoffs) *
15469 if (probe->dofpr_noffs + probe->dofpr_nenoffs == 0) {
15470 dtrace_dof_error(dof, "zero probe and "
15474 } else if (probe->dofpr_noffs == 0) {
15475 dtrace_dof_error(dof, "zero probe offsets");
15479 if (probe->dofpr_argidx + probe->dofpr_xargc <
15480 probe->dofpr_argidx ||
15481 (probe->dofpr_argidx + probe->dofpr_xargc) *
15487 typeidx = probe->dofpr_nargv;
15488 typestr = strtab + probe->dofpr_nargv;
15489 for (k = 0; k < probe->dofpr_nargc; k++) {
15506 typeidx = probe->dofpr_xargv;
15507 typestr = strtab + probe->dofpr_xargv;
15508 for (k = 0; k < probe->dofpr_xargc; k++) {
15509 if (arg[probe->dofpr_argidx + k] > probe->dofpr_nargc) {
15685 * much less any in probe context.
15901 dtrace_probe_t template, *probe, *first, *next;
15921 for (probe = first = dtrace_hash_lookup(dtrace_bymod, &template);
15922 probe != NULL; probe = probe->dtpr_nextmod) {
15923 if (probe->dtpr_ecb != NULL) {
15930 * unloading a module that has an enabled probe in it.
15936 * probe, either.
15947 probe = first;
15949 for (first = NULL; probe != NULL; probe = next) {
15950 ASSERT(dtrace_probes[probe->dtpr_id - 1] == probe);
15952 dtrace_probes[probe->dtpr_id - 1] = NULL;
15954 next = probe->dtpr_nextmod;
15955 dtrace_hash_remove(dtrace_bymod, probe);
15956 dtrace_hash_remove(dtrace_byfunc, probe);
15957 dtrace_hash_remove(dtrace_byname, probe);
15960 first = probe;
15961 probe->dtpr_nextmod = NULL;
15963 probe->dtpr_nextmod = first;
15964 first = probe;
15970 * from the probe array. Now issue a dtrace_sync() to be sure that
15971 * everyone has cleared out from any probe array processing.
15975 for (probe = first; probe != NULL; probe = first) {
15976 first = probe->dtpr_nextmod;
15977 prov = probe->dtpr_provider;
15978 prov->dtpv_pops.dtps_destroy(prov->dtpv_arg, probe->dtpr_id,
15979 probe->dtpr_arg);
15980 kmem_free(probe->dtpr_mod, strlen(probe->dtpr_mod) + 1);
15981 kmem_free(probe->dtpr_func, strlen(probe->dtpr_func) + 1);
15982 kmem_free(probe->dtpr_name, strlen(probe->dtpr_name) + 1);
15983 vmem_free(dtrace_arena, (void *)(uintptr_t)probe->dtpr_id, 1);
15984 kmem_free(probe, sizeof (dtrace_probe_t));
16115 * in probe context -- that assures that a dtrace_sync() can be used
16388 * CPU is in probe context with enabled helper tracing
16784 dtrace_probe_t *probe = NULL;
16802 * Before we attempt to match this probe, we want to give
16823 if ((probe = dtrace_probes[i - 1]) != NULL &&
16824 (m = dtrace_match_probe(probe, &pkey,
16836 if ((probe = dtrace_probes[i - 1]) != NULL &&
16837 dtrace_match_priv(probe, priv, uid, zoneid))
16842 if (probe == NULL) {
16847 dtrace_probe_description(probe, &desc);
16858 dtrace_probe_t *probe;
16881 if ((probe = dtrace_probes[desc.dtargd_id - 1]) == NULL) {
16890 prov = probe->dtpr_provider;
16894 * There isn't any typed information for this probe.
16904 probe->dtpr_id, probe->dtpr_arg, &desc);
17396 nulldev, /* probe */