Lines Matching defs:this
4 * The contents of this file are subject to the terms of the
6 * You may not use this file except in compliance with the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
15 * If applicable, add the following below this CDDL HEADER, with the
151 * In general, the only variables that one should be tuning this way are those
209 * well-known, zero-filled memory. While this variable is not documented,
399 * outside of the implementation. There is no real structure to this cpp
623 * Some functions in this block are not actually called from probe context;
678 * To save this code both the infamy of being fingered
682 * likelihood of this condition -- but suffice it to
869 * DTrace subroutines (DIF_SUBR_*) should use this helper to implement
932 * and it is therefore impossible for this memory to be
1044 * this exists so that we don't need to issue unnecessary dtrace_strlen()
1100 * DTRACE_ACCESS_KERNEL-credentialed callers expect that this function
1112 * in this case.
1366 * Zero the specified region using a simple byte-by-byte loop. Note that this
1477 * is null (anonymous tracing), we fast-path bypass this routine.
1506 * is null (anonymous tracing), we fast-path bypass this routine.
1611 * the current probe to continue. Note that this routine may allow continued
1638 * If the dte_cond bits indicate that this consumer is only allowed to
1639 * see user-mode firings of this probe, call the provider's dtps_mode()
1661 * Currently, the only times we'll this check is if a non-super-user
1745 * this CPU was selected to accept another CPU's
1760 * move the dirty list into the clean list on this
1761 * CPU, yet we also don't want to allow this condition
1765 * drops). To deal with this, we look for some CPU
1767 * rinsing list -- and then we borrow this CPU to
1791 * could accept this dirty list -- we are
1837 * into this dirty list; we can make it clean.
1857 * Depending on the value of the op parameter, this function looks-up,
1859 * allocation is requested, this function will return a pointer to a
1887 * over each referenced byte. It's painful to do this, but it's much
1939 * comes out to be one of our two sentinel hash values. If this
2002 * the line, one of the members of this hash
2004 * detect this by simply letting this loop run
2009 * long), so we catch this as early as
2011 * this case, we simply set dvar to NULL and
2086 * Finally, unlock this hash bucket.
2102 * was deleted while we were traversing it. In this case,
2143 * strange DIF specified the tuple. Ideally, this should be an
2148 * solving this would presumably not amount to solving the Halting
2170 * this CPU. Unless we have tried all CPUs,
2246 * It's impossible for this to fail: the only way
2247 * the free list can be updated is through this
2249 * Thus, it would only be possible for this to fail if
2250 * this code were racing with dtrace_dynvar_clean().
2271 * following the tuple array. As we do this, we relocate dttk_value
2304 * this hash chain, or another CPU is deleting an element from this
2404 int64_t this = 1, last, next;
2411 this *= factor;
2417 if (value < (last = this))
2420 for (this *= factor; order <= high; order++) {
2421 int nbuckets = this > nsteps ? nsteps : this;
2423 if ((next = this * factor) < this) {
2427 * overflow, but we nonetheless protect against this
2431 value = this - 1;
2434 if (value < this) {
2436 * If our value lies within this order of magnitude,
2441 return (base + (value - last) / (this / nbuckets));
2445 last = this;
2446 this = next;
2493 * we do this as 128-bit arithmetic.
2574 * buckets. If this guess ends up being routinely
2575 * off-the-mark, we may need to dynamically readjust this
2686 * the value at this key.
2774 * Given consumer state, this routine finds a speculation in the INACTIVE
2776 * in the INACTIVE state, 0 is returned. In this case, no error counter is
2807 * busy speculation buffer, we'll attribute this failure as "busy"
2819 * is not in a valid state to perform a commit(), this routine will silently do
2860 * without having done a prior speculate() on this CPU
2897 * We have set the state to indicate that we are committing this
2938 * Copy the buffer across. (Note that this is a
2939 * highly subobtimal bcopy(); in the unlikely event that this becomes
2970 * If we're lucky enough to be the only active CPU on this speculation
2988 * is not in a valid state to perform a discard(), this routine will silently
3223 * dtrace_dif_variable() uses this routine as a helper for various
3235 * The easy case: this probe is allowed to read all of memory, so
3236 * we can just return this as a vanilla pointer.
3243 * kernel memory into scratch memory and return it that way: this
3269 * dtrace_dif_variable() uses this routine as a helper for various
3309 * If we're accessing one of the uncached arguments, we'll turn this
3339 * (None of this would be necessary if the compiler
3465 * If this is an unanchored probe, we are
3478 * We have failed to do this the quick way;
3697 * credential, since this is never NULL after process birth.
3722 * credential, since this is never NULL after process birth.
3743 * the event that this pointer is non-NULL. (This is true
3794 * The run time of this function must be bounded above by strsize to limit the
3802 * other error condition. Each NULL return in this function is commented with
3830 * states return to this state at the end of their value, unless otherwise
3852 * embedded strings. If the full element selector list matches this nested
3853 * object, we return the Object in full as a string. If not, we use this
3854 * state to skip to the next value at this level and continue processing.
3950 * this string.
4036 * not this identifier.
4095 * this number.
4114 * to descend into this nested object,
4139 * Otherwise, we wish to either skip this
4692 * the string length or we have found the character. If this
4728 * the string length or we have found the string. (Yes, this
4793 * the string. Given this notion, Perl's
4800 * this case, even if the position is
4901 * strtok pointer from the mstate. Note that this
4912 * a chance to do so, since this address may reside
4913 * in the string table of this clause-- future calls
4915 * would fail this access check.
4957 * We return NULL in this case, and we set the saved
5182 * read privileges to use this routine.
5199 * We want to have a name for the minor. In order to do this,
5205 * same element. You may recognize this little trick as the
5210 * this technique. Needless to say, those conditions are
5211 * found here -- and probably only here. Is this the only use
5212 * of this infamous trick in shipping, production code? If it
5617 * because lastdir is -1, we know that this
5620 * "/basename".) In this case, the last
5710 * just store the "/" and this character and
5732 * "/." and this character and continue
5746 * We'll store the "/.." and this character
5775 * If we've done a getf() as a part of this ECB and we
5779 * that this is an output cleanliness issue, not a
6406 * then this is to be treated as a
6472 * For now, this has no meaning.
6499 * then this is to be treated as a
6657 * If this is a string type and the size is 0,
6661 * had this been set, we would expect to have
7076 * exception to this rule, however.
7187 * abort processing -- this needn't be a fatal error -- but we
7189 * allow this condition to be warned about. (If this is from
7214 * If this is a string, we're going to only load until we find the zero
7272 * Unless this is an ERROR probe, we are not allowed to recurse in
7276 * resulting in unexpected output. If there is an exception to this
7323 * Kick out immediately if this CPU is still being born (in which case
7340 * this predicate would evaluate to be false.
7406 * If dtrace itself is the provider of this probe,
7441 * If the dte_cond bits indicate that this
7443 * of this probe, call the provider's dtps_usermode()
7445 * while in a user context. Skip this ECB if that's
7459 * situations. Currently, the only times we'll this
7508 * on this state will be performed.
7662 * routine to perform this processing.
7841 * draining. If this fails (either because
7937 * this condition happened.
7986 * The functions in this section (and indeed, the functions in remaining
7987 * sections) are not _called_ from probe context. (Any exceptions to this are
8152 * Find the bucket that we're removing this probe from.
8164 * The removed probe was the only probe on this
8210 * this function returns a zero-length string.
8682 * described in <sys/dtrace.h>. The parts of the API not in this section are
8795 * If there is at least one provider registered, we'll add this
8868 * probes, we refuse to let providers slither away, unless this
8885 * Attempt to destroy the probes associated with this provider.
8904 * instead of EBUSY) in this case.
8928 * All of the probes for this provider are disabled; we can safely
9056 * Make sure this isn't the dtrace provider itself.
9065 * Attempt to destroy the probes associated with this provider.
9105 * The functions in this section perform the DTrace probe management,
9322 * that this also prevents the mod_busy bits from changing.
9550 * any retained enablings. Note that this call will acquire both
10001 * NULL if this is a helper -- but in that
10086 * For user-defined variables, we need to check that this
10424 * We need to check this DIF object for references to the variable
10441 * malicious DIF -- but it works for all compiler-generated DIF. Because this
10573 * We have the size. If this is larger than the chunk size
10951 * cacheable predicates on this machine. We cannot allow any
10955 * have this cmn_err() "Holy shit -- we executed this code!")
11095 * If this state is active, we must dtrace_sync()
11140 * We're the first ECB on this probe.
11402 * We need to allocate an id for this aggregation.
11487 * If this is an aggregating action, there must be neither
11668 * If this is a data-storing action or a speculate,
11888 * model to be enforced, and this is what DTRACE_COND_OWNER
11957 * This probe was created in a generation for which this
12014 * buffers on a given CPU. The atomicity of this operation is assured by
12063 * but this isn't necessarily true: the buffer for the CPU
12065 * manually. In this case, we take the (harmless) action
12118 * If there is already a buffer allocated for this CPU, it
12119 * is only possible that this is a DR event. In this case,
12197 * If there is already a buffer allocated for this CPU, it
12198 * is only possible that this is a DR event. In this case,
12363 * to an error or false predicate evaluation. In this
12366 * for this allocation, it will be adjusted in the
12450 * this case, the buffer is indistinguishable
12528 * between the buffer offset and the wrapped offset. In this case,
12537 * didn't subsequently consume the buffer space. In this case,
12545 * was not subsequently consumed. In this case, we need to zero the
12748 * If this was a retained enabling, decrement the dts_nretained count
12934 * the face of such errors. If this is an anonymous
12968 * against them. We only perform this operation on enablings for which
12996 * transition out of DTRACE_ACTIVITY_INACTIVE. To do this without actually
12998 * NULL probe -- which is exactly what this function does.
13116 * eliminate) the possibility of this, we will only destroy an
13177 * DOF containing the run-time options -- but this could be expanded to create
13500 * this type and NULL is returned if the types do not match.
13717 * known to us, assume this is a broken program and fail.
13738 * this should _not_ happen if the "strsize" option has been set --
13739 * in this case, the compiler should have set the size to reflect the
13839 * DOF string table. For printf()-like actions, this
13840 * is the format string. For print(), this is the
14217 * relocations that are present. We do this after the first pass to
14621 * We allocate NCPU buffers. On the one hand, this can be quite
14632 * assumed to be seeded at this point (if from Fortuna seed file).
14688 * Set up the credentials for this instantiation. We take a
14690 * us; this in turn prevents the zone_t referenced by this
14730 * If we have all privs in whatever zone this is,
14752 * this doesn't mean that all actions become available
14762 * for *this* zone are allowed.
14770 * for this user/group ID in all zones is allowed.
14778 * If we have all privs in whatever zone this is,
14857 * of ENOMEM in this case to allow for user-level
14952 * retained enablings that correspond to this state.
14966 * this fails, we will fail the operation.
15038 * aggregations -- set this option to 0.
15152 * this is the first enabling to have an unprivileged call
15167 * probe (the data from this CPU will be processed first at user
15168 * level) and to manually activate the buffer for this CPU.
15203 * INACTIVE state. Doing this assures that no CPU will suddenly begin
15258 * on why this is done.
15264 * By this point, it is impossible for any CPU to be still processing
15279 * allows user-land to be sure that this CPU's principal buffer is
15299 * this is the last enabling to have an unprivileged call
15349 * If this is an otherwise negative value, set it to
15353 * this has no effect -- if we set the buffer size to
15388 * First, retract any retained enablings for this state.
15399 * exiting without having called dtrace_stop().) In this case,
15557 * this fails (e.g. because the debugger has modified text in
15584 * processing anonymous state in this case.
15732 * from machine state; this is okay, too.
15873 * Move the last helper provider into this slot.
15882 * If we have a meta provider, remove this helper provider.
15938 * If we already have dtrace_helper_actions_max helper actions for this
16067 * Check to make sure this isn't a duplicate.
16236 * skip this probe in dtrace_helper_provide_one().
16408 * Adding this helper action failed -- we are now going
16429 * Now that this is in-kernel, we change the sense of the
16491 * We're now going to lose the help from this process.
16670 * specifying only this module.
16684 * module. (In particular, this happens when loading scheduling
16703 * this, because it would lead us to the lock ordering violation
16782 * this can't happen.) However, because dtps_enable()
16996 * that contain calls to getf(), this routine will be called on every
17126 * that there should be no other retained enablings at this time:
17127 * the only retained enablings at this time should be the anonymous
17192 * If this wasn't an open with the "helper" minor, then it must be
17573 * If this action has a record size of zero, it
17575 * Because the presence of this record doesn't (or
17649 * If a NULL argument has been passed, we take this as our
17746 * Before we attempt to match this probe, we want to give
17838 * There isn't any typed information for this probe.
17936 * If this buffer has already been consumed, we're
17956 * If this is a ring buffer that has wrapped, we want
18002 * not in the ready set. If this is the case, we'll return
18216 * If there were ECBs on this state, the provider should
18354 &mod_driverops, /* module type (this is a pseudo driver) */