Lines Matching defs:key
456 * Non-Leaf: | header | key 1 | key 2 | key N | ptr 1 | ptr 2 | ptr N |
461 * pointers. The record and key structures are defined by the btree instances
465 * The helpers below calculate the offset of a given record, key or pointer
467 * record, key or pointer (xfs_btree_*_addr). Note that all addressing
472 * highest and indexed by the smallest key value that refers to the record.
474 * indexing the lowest key available in the block(s) below (the same behavior
475 * as the key in a regular btree) and another indexing the highest key
477 * highest key, all leaf block updates require us to compute the highest key
491 * with the lowest key and iterate forward until a non-matching record is
552 * Calculate offset of the n-th key in a btree block.
564 * Calculate offset of the n-th high key in a btree block.
603 * Return a pointer to the n-th key in the btree block.
616 * Return a pointer to the n-th high key in the btree block.
715 * Set the ptr value to 1, that's the first record/key.
745 * Set the ptr value to numrecs, that's the last record/key.
1338 union xfs_btree_key *key,
1347 dst_key = (char *)key + (dir * cur->bc_ops->key_len);
1348 memmove(dst_key, key, numkeys * cur->bc_ops->key_len);
1390 * Log key values from the btree block.
1599 * pointers and key numbers.
1692 * pointers and key numbers.
1781 * Get current search key. For level 0 we don't actually have a key
1783 * we just return the right key.
1813 int64_t diff; /* difference for the current key */
1815 int keyno; /* current key number */
1835 * For each level above the leaves, find the key we need, based
1847 * If we already had a key match at a higher level, we
1877 union xfs_btree_key key;
1885 /* Get current search key */
1887 keyno, block, &key);
1911 * If we moved left, need the previous key number,
1965 /* Find the high key storage area from a regular key. */
1969 union xfs_btree_key *key)
1972 return (union xfs_btree_key *)((char *)key +
1981 union xfs_btree_key *key)
1990 cur->bc_ops->init_key_from_rec(key, rec);
2003 high = xfs_btree_high_key_from_key(cur, key);
2013 union xfs_btree_key *key)
2021 memcpy(key, xfs_btree_key_addr(cur, 1, block),
2031 high = xfs_btree_high_key_from_key(cur, key);
2034 memcpy(key, xfs_btree_key_addr(cur, 1, block),
2044 union xfs_btree_key *key)
2047 xfs_btree_get_leaf_keys(cur, block, key);
2049 xfs_btree_get_node_keys(cur, block, key);
2055 * record/key. For an overlapping btree, we must always update the
2056 * keys because the highest key can be in any of the records or keys
2080 union xfs_btree_key key; /* keys from current level */
2096 lkey = &key;
2151 union xfs_btree_key key;
2162 * At each level, update the key value to the value input.
2166 xfs_btree_get_keys(cur, block, &key);
2179 xfs_btree_copy_keys(cur, kp, &key, 1);
2227 /* Pass new key value up to our parent. */
2258 union xfs_btree_key *rkp = NULL; /* right btree key */
2313 * If non-leaf, copy a key and a ptr to the left block.
2318 union xfs_btree_key *lkp; /* left btree key */
2389 * Using a temporary cursor, update the parent key values of the
2453 union xfs_btree_key *rkp; /* right btree key */
2560 * Using a temporary cursor, update the parent key values of the
2607 * Return new block number and the key to its first
2615 union xfs_btree_key *key,
2688 union xfs_btree_key *lkp; /* left btree key */
2690 union xfs_btree_key *rkp; /* right btree key */
2712 xfs_btree_get_node_keys(cur, right, key);
2726 xfs_btree_get_leaf_keys(cur, right, key);
2795 union xfs_btree_key *key;
2829 args->key, args->curp, args->stat);
2852 union xfs_btree_key *key,
2860 return __xfs_btree_split(cur, level, ptrp, key, curp, stat);
2865 args.key = key;
2891 union xfs_btree_key *ckp; /* child key pointer */
2893 union xfs_btree_key *kp; /* pointer to btree key */
2996 int nptr; /* new value for key index, 1 or 2 */
3067 /* Fill in the key data in the new root. */
3119 union xfs_btree_key *key, /* key of new block */
3167 error = xfs_btree_split(cur, level, nptr, key, ncur, stat);
3186 union xfs_btree_key *key, /* i/o: block key for ptrp */
3194 union xfs_btree_key nkey; /* new block key */
3196 int optr; /* old key/record index */
3197 int ptr; /* key/record index */
3245 ASSERT(cur->bc_ops->keys_inorder(cur, key,
3304 xfs_btree_copy_keys(cur, kp, key, 1);
3344 * some records into the new tree block), so use the regular key
3370 xfs_btree_copy_keys(cur, key, lkey, 1);
3401 union xfs_btree_key bkey; /* key of block to insert */
3402 union xfs_btree_key *key;
3408 key = &bkey;
3412 /* Make a key out of the record data to be inserted, and save it. */
3414 cur->bc_ops->init_key_from_rec(key, &rec);
3426 error = xfs_btree_insrec(pcur, level, &nptr, &rec, key,
3644 int ptr; /* key/record index */
3663 /* Get the buffer & block containing the record or key/ptr. */
3775 * key values above us in the tree.
4040 union xfs_btree_key *lkp; /* left btree key */
4042 union xfs_btree_key *rkp; /* right btree key */
4538 * Start with a LE lookup of the key of low_rec and return all records
4539 * until we find a record with a key greater than the key of high_rec.
4629 * As an optimization, we stop scanning a block when we find a low key
4630 * that is greater than the query's high key.
4695 * If (record's high key >= query's low key) and
4696 * (query's high key >= record's low key), then
4704 /* Record is larger than high key; pop. */
4720 * If (pointer's high key >= query's low key) and
4721 * (query's high key >= pointer's low key), then
4740 /* The low key is larger than the upper range; pop. */
4795 /* Enforce low key < high key. */