Lines Matching defs:key
528 * Non-Leaf: | header | key 1 | key 2 | key N | ptr 1 | ptr 2 | ptr N |
533 * pointers. The record and key structures are defined by the btree instances
537 * The helpers below calculate the offset of a given record, key or pointer
539 * record, key or pointer (xfs_btree_*_addr). Note that all addressing
544 * highest and indexed by the smallest key value that refers to the record.
546 * indexing the lowest key available in the block(s) below (the same behavior
547 * as the key in a regular btree) and another indexing the highest key
549 * highest key, all leaf block updates require us to compute the highest key
563 * with the lowest key and iterate forward until a non-matching record is
624 * Calculate offset of the n-th key in a btree block.
636 * Calculate offset of the n-th high key in a btree block.
675 * Return a pointer to the n-th key in the btree block.
688 * Return a pointer to the n-th high key in the btree block.
787 * Set the ptr value to 1, that's the first record/key.
817 * Set the ptr value to numrecs, that's the last record/key.
1410 union xfs_btree_key *key,
1419 dst_key = (char *)key + (dir * cur->bc_ops->key_len);
1420 memmove(dst_key, key, numkeys * cur->bc_ops->key_len);
1462 * Log key values from the btree block.
1671 * pointers and key numbers.
1764 * pointers and key numbers.
1853 * Get current search key. For level 0 we don't actually have a key
1855 * we just return the right key.
1885 int64_t diff; /* difference for the current key */
1887 int keyno; /* current key number */
1907 * For each level above the leaves, find the key we need, based
1919 * If we already had a key match at a higher level, we
1949 union xfs_btree_key key;
1957 /* Get current search key */
1959 keyno, block, &key);
1983 * If we moved left, need the previous key number,
2037 /* Find the high key storage area from a regular key. */
2041 union xfs_btree_key *key)
2044 return (union xfs_btree_key *)((char *)key +
2053 union xfs_btree_key *key)
2062 cur->bc_ops->init_key_from_rec(key, rec);
2074 high = xfs_btree_high_key_from_key(cur, key);
2084 union xfs_btree_key *key)
2092 memcpy(key, xfs_btree_key_addr(cur, 1, block),
2102 high = xfs_btree_high_key_from_key(cur, key);
2105 memcpy(key, xfs_btree_key_addr(cur, 1, block),
2115 union xfs_btree_key *key)
2118 xfs_btree_get_leaf_keys(cur, block, key);
2120 xfs_btree_get_node_keys(cur, block, key);
2126 * record/key. For an overlapping btree, we must always update the
2127 * keys because the highest key can be in any of the records or keys
2151 union xfs_btree_key key; /* keys from current level */
2167 lkey = &key;
2222 union xfs_btree_key key;
2233 * At each level, update the key value to the value input.
2237 xfs_btree_get_keys(cur, block, &key);
2250 xfs_btree_copy_keys(cur, kp, &key, 1);
2298 /* Pass new key value up to our parent. */
2329 union xfs_btree_key *rkp = NULL; /* right btree key */
2384 * If non-leaf, copy a key and a ptr to the left block.
2389 union xfs_btree_key *lkp; /* left btree key */
2460 * Using a temporary cursor, update the parent key values of the
2524 union xfs_btree_key *rkp; /* right btree key */
2631 * Using a temporary cursor, update the parent key values of the
2678 * Return new block number and the key to its first
2686 union xfs_btree_key *key,
2759 union xfs_btree_key *lkp; /* left btree key */
2761 union xfs_btree_key *rkp; /* right btree key */
2783 xfs_btree_get_node_keys(cur, right, key);
2797 xfs_btree_get_leaf_keys(cur, right, key);
2867 union xfs_btree_key *key;
2901 args->key, args->curp, args->stat);
2937 union xfs_btree_key *key,
2946 return __xfs_btree_split(cur, level, ptrp, key, curp, stat);
2951 args.key = key;
2980 union xfs_btree_key *ckp; /* child key pointer */
2982 union xfs_btree_key *kp; /* pointer to btree key */
3087 int nptr; /* new value for key index, 1 or 2 */
3158 /* Fill in the key data in the new root. */
3211 union xfs_btree_key *key, /* key of new block */
3259 error = xfs_btree_split(cur, level, nptr, key, ncur, stat);
3278 union xfs_btree_key *key, /* i/o: block key for ptrp */
3286 union xfs_btree_key nkey; /* new block key */
3288 int optr; /* old key/record index */
3289 int ptr; /* key/record index */
3337 ASSERT(cur->bc_ops->keys_inorder(cur, key,
3396 xfs_btree_copy_keys(cur, kp, key, 1);
3436 * some records into the new tree block), so use the regular key
3462 xfs_btree_copy_keys(cur, key, lkey, 1);
3493 union xfs_btree_key bkey; /* key of block to insert */
3494 union xfs_btree_key *key;
3500 key = &bkey;
3504 /* Make a key out of the record data to be inserted, and save it. */
3506 cur->bc_ops->init_key_from_rec(key, &rec);
3518 error = xfs_btree_insrec(pcur, level, &nptr, &rec, key,
3736 int ptr; /* key/record index */
3755 /* Get the buffer & block containing the record or key/ptr. */
3867 * key values above us in the tree.
4132 union xfs_btree_key *lkp; /* left btree key */
4134 union xfs_btree_key *rkp; /* right btree key */
4705 * Start with a LE lookup of the key of low_rec and return all records
4706 * until we find a record with a key greater than the key of high_rec.
4792 * As an optimization, we stop scanning a block when we find a low key
4793 * that is greater than the query's high key.
4853 * If (query's high key < record's low key), then there
4857 * If (record's high key >= query's low key) and
4858 * (query's high key >= record's low key), then
4879 * If (query's high key < pointer's low key), then there are no
4883 * If (pointer's high key >= query's low key) and
4884 * (query's high key >= pointer's low key), then
4934 union xfs_btree_key *key,
4941 cur->bc_ops->init_key_from_rec(key, &rec);
4965 /* Enforce low key <= high key. */
5033 /* Mask for key comparisons, if desired. */
5036 /* Highest record key we've seen so far. */
5059 * If the first record we find does not overlap the start key,
5084 * If high_key(rec) is larger than any other high key we've seen,
5101 * For most btree types, the record scan should use all available btree key