Lines Matching refs:key
331 * The key for a thread-local variable consists of the lower 61 bits of the
333 * We add DIF_VARIABLE_MAX to t_did to assure that the thread key is never
339 * [ key0 ] ... [ keyn ] [ variable-key ] [ tls-key ]
341 * Because the variable-key and the tls-key are in orthogonal spaces, there is
342 * no way for a global variable key signature to match a thread-local key
1751 dtrace_key_t *key, size_t dsize, dtrace_dynvar_op_t op,
1767 * Hash the key. As with aggregations, we use Jenkins' "One-at-a-time"
1778 if (key[i].dttk_size == 0) {
1779 uint64_t val = key[i].dttk_value;
1801 uint64_t j, size = key[i].dttk_size;
1802 uintptr_t base = (uintptr_t)key[i].dttk_value;
1911 if (dkey->dttk_size != key[i].dttk_size)
1916 (void *)(uintptr_t)key[i].dttk_value,
1921 if (dkey->dttk_value != key[i].dttk_value)
2019 * size of any auxiliary key data (rounded up to 8-byte alignment) plus
2024 ksize += P2ROUNDUP(key[i].dttk_size, sizeof (uint64_t));
2155 * tuple array and copy any referenced key data into the data space
2157 * in the final tuple to point to the key data address in the chunk.
2165 size_t kesize = key[i].dttk_size;
2169 (const void *)(uintptr_t)key[i].dttk_value,
2174 dkey->dttk_value = key[i].dttk_value;
2416 dtrace_aggkey_t *key;
2495 * Calculate the hash value based on the key. Note that we _don't_
2497 * the key). The hashing algorithm is Bob Jenkins' "One-at-a-time"
2530 for (key = agb->dtagb_hash[ndx]; key != NULL; key = key->dtak_next) {
2531 ASSERT((caddr_t)key >= tomax);
2532 ASSERT((caddr_t)key < tomax + buf->dtb_size);
2534 if (hashval != key->dtak_hashval || key->dtak_size != size)
2537 kdata = key->dtak_data;
2556 if (action != key->dtak_action) {
2571 * the value at this key.
2589 * If we don't have enough room to both allocate a new key _and_
2600 key = (dtrace_aggkey_t *)(agb->dtagb_free - sizeof (dtrace_aggkey_t));
2603 key->dtak_data = kdata = tomax + offs;
2645 key->dtak_hashval = hashval;
2646 key->dtak_size = size;
2647 key->dtak_action = action;
2648 key->dtak_next = agb->dtagb_hash[ndx];
2649 agb->dtagb_hash[ndx] = key;
2654 *((uint64_t *)(key->dtak_data + size)) = agg->dtag_initial;
2655 agg->dtag_aggregate((uint64_t *)(key->dtak_data + size), expr, arg);
3583 * clause execution, we simply return NULL in the event of a missing key or any
3595 * Locate the next key String in an Object. Sets a flag to denote
3596 * the next String as a key string and moves to DTRACE_JSON_STRING.
3599 * Skip whitespace until we find the colon that separates key Strings
3609 * Skip whitespace until we find the comma that separates key-value pairs
3626 * a key, a value or part of a larger Object. Handles all escape sequences
3629 * actual escaped character. If the String is flagged as a key, we
3698 * ERROR: either the object did not start with a key
3700 * without finding the requested key.
3799 * finding the requested key.
4748 * If the first element selector key is
6167 dtrace_key_t *key;
6174 key = &tupregs[DIF_DTR_NREGS];
6175 key[0].dttk_value = (uint64_t)id;
6176 key[0].dttk_size = 0;
6177 DTRACE_TLS_THRKEY(key[1].dttk_value);
6178 key[1].dttk_size = 0;
6180 dvar = dtrace_dynvar(dstate, 2, key,
6200 dtrace_key_t *key;
6207 key = &tupregs[DIF_DTR_NREGS];
6208 key[0].dttk_value = (uint64_t)id;
6209 key[0].dttk_size = 0;
6210 DTRACE_TLS_THRKEY(key[1].dttk_value);
6211 key[1].dttk_size = 0;
6214 dvar = dtrace_dynvar(dstate, 2, key,
6308 dtrace_key_t *key = tupregs;
6315 key[nkeys].dttk_value = (uint64_t)id;
6316 key[nkeys++].dttk_size = 0;
6319 DTRACE_TLS_THRKEY(key[nkeys].dttk_value);
6320 key[nkeys++].dttk_size = 0;
6328 dvar = dtrace_dynvar(dstate, nkeys, key,
6350 dtrace_key_t *key = tupregs;
6357 key[nkeys].dttk_value = (uint64_t)id;
6358 key[nkeys++].dttk_size = 0;
6361 DTRACE_TLS_THRKEY(key[nkeys].dttk_value);
6362 key[nkeys++].dttk_size = 0;
6370 dvar = dtrace_dynvar(dstate, nkeys, key,
7821 * dtrace_match_probe compares a dtrace_probe_t to a pre-compiled key, which
8004 * If the probe ID is specified in the key, just lookup by ID and
8047 * invoke our callback for each one that matches our input probe key.
8070 * If we selected a hash table, iterate over each probe of the same key
8072 * attributes of our input probe key.
8115 * Build a probe comparison key for use with dtrace_match_probe() from the
8116 * given probe description. By convention, a null key only matches anchored
9890 dtrace_key_t *key = tupregs;
9899 key = &tupregs[DIF_DTR_NREGS];
9900 key[0].dttk_size = 0;
9901 key[1].dttk_size = 0;
9911 key[nkeys++].dttk_size = 0;
9913 key[nkeys++].dttk_size = 0;
9975 ksize += P2ROUNDUP(key[i].dttk_size, sizeof (uint64_t));