Lines Matching defs:key
118 * key ranges and transaction ids to find items for a given file or directory
331 * Item overwrite used by replay and tree logging. eb, slot and key all refer
338 * If the key is already in the destination tree the existing item is
342 * If the key isn't in the destination yet, a new item is inserted.
348 struct btrfs_key *key)
357 bool inode_item = key->type == BTRFS_INODE_ITEM_KEY;
365 /* look for the key in the destination tree */
366 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
458 /* try to insert the key into the destination tree */
461 key, item_size);
488 if (key->type == BTRFS_INODE_ITEM_KEY && ret == -EEXIST) {
532 if (key->type == BTRFS_INODE_ITEM_KEY) {
561 /* replays a single extent in 'eb' at 'slot' with 'key' into the
577 struct btrfs_key *key)
582 u64 start = key->offset;
613 inode = read_one_inode(root, key->objectid);
670 ret = btrfs_insert_empty_item(trans, root, path, key,
682 offset = key->offset - btrfs_file_extent_offset(eb, item);
719 key->objectid, offset);
730 key->objectid, offset, &ins);
764 * key (257 EXTENT_DATA 409600)
768 * key (257 EXTENT_DATA 819200)
777 * key (EXTENT_CSUM EXTENT_CSUM 12845056) itemsize 100
782 * key (EXTENT_CSUM EXTENT_CSUM 12865536) itemsize 20
790 * key (EXTENT_CSUM EXTENT_CSUM 12845056) itemsize 100
791 * key (EXTENT_CSUM EXTENT_CSUM 12865536) itemsize 20
823 ret = overwrite_item(trans, root, path, eb, slot, key);
952 struct btrfs_key *key,
963 ret = btrfs_search_slot(NULL, log, key, path, 0, 0);
971 if (key->type == BTRFS_INODE_EXTREF_KEY)
1222 * inode reference item in the subvolume tree with the same key (if it exists).
1233 struct btrfs_key *key)
1242 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
1258 if (key->type == BTRFS_INODE_EXTREF_KEY) {
1262 parent_id = key->offset;
1269 if (key->type == BTRFS_INODE_EXTREF_KEY)
1307 if (key->type == BTRFS_INODE_EXTREF_KEY)
1322 struct btrfs_key key;
1331 key.objectid = btrfs_ino(BTRFS_I(inode));
1332 key.type = ref_type;
1333 if (key.type == BTRFS_INODE_REF_KEY)
1334 key.offset = parent_id;
1336 key.offset = btrfs_extref_hash(parent_id, name, namelen);
1338 ret = btrfs_search_slot(NULL, BTRFS_I(inode)->root, &key, path, 0, 0);
1345 if (key.type == BTRFS_INODE_EXTREF_KEY)
1362 struct btrfs_key key;
1387 btrfs_dir_item_key_to_cpu(path->nodes[0], dir_item, &key);
1389 other_inode = read_one_inode(root, key.objectid);
1420 * eb, slot and key refer to the buffer and key found in the log tree.
1429 struct btrfs_key *key)
1448 if (key->type == BTRFS_INODE_EXTREF_KEY) {
1457 parent_objectid = key->offset;
1459 inode_objectid = key->objectid;
1537 ret = btrfs_inode_ref_exists(inode, dir, key->type,
1592 key);
1597 ret = overwrite_item(trans, root, path, eb, slot, key);
1666 struct btrfs_key key;
1673 key.objectid = ino;
1674 key.type = BTRFS_INODE_REF_KEY;
1675 key.offset = (u64)-1;
1678 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1687 btrfs_item_key_to_cpu(path->nodes[0], &key,
1689 if (key.objectid != ino ||
1690 key.type != BTRFS_INODE_REF_KEY)
1705 if (key.offset == 0)
1711 key.offset--;
1782 struct btrfs_key key;
1785 key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
1786 key.type = BTRFS_ORPHAN_ITEM_KEY;
1787 key.offset = (u64)-1;
1789 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1800 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1801 if (key.objectid != BTRFS_TREE_LOG_FIXUP_OBJECTID ||
1802 key.type != BTRFS_ORPHAN_ITEM_KEY)
1810 inode = read_one_inode(root, key.offset);
1826 key.offset = (u64)-1;
1843 struct btrfs_key key;
1851 key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
1852 key.type = BTRFS_ORPHAN_ITEM_KEY;
1853 key.offset = objectid;
1855 ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
1928 struct btrfs_key *key)
1939 bool update_size = (key->type == BTRFS_DIR_INDEX_KEY);
1942 dir = read_one_inode(root, key->objectid);
1965 if (key->type == BTRFS_DIR_ITEM_KEY) {
1966 dst_di = btrfs_lookup_dir_item(trans, root, path, key->objectid,
1968 } else if (key->type == BTRFS_DIR_INDEX_KEY) {
1970 key->objectid,
1971 key->offset, name,
1989 if (key->type != BTRFS_DIR_INDEX_KEY)
2015 if (key->type == BTRFS_DIR_INDEX_KEY)
2036 found_key.offset = key->objectid;
2049 found_key.offset = key->objectid;
2050 ret = backref_in_log(root->log_root, &found_key, key->objectid, name,
2061 ret = insert_one_name(trans, root, key->objectid, key->offset,
2082 struct btrfs_key *key)
2097 ret = replay_one_name(trans, root, path, eb, di, key);
2158 * The range items tell us which parts of the key space the log
2159 * is authoritative for. During replay, if a key in the subvolume
2169 struct btrfs_key key;
2178 key.objectid = dirid;
2179 key.type = key_type;
2180 key.offset = *start_ret;
2182 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2191 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2193 if (key.type != key_type || key.objectid != dirid) {
2201 if (*start_ret >= key.offset && *start_ret <= found_end) {
2203 *start_ret = key.offset;
2218 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2220 if (key.type != key_type || key.objectid != dirid) {
2227 *start_ret = key.offset;
2317 /* there might still be more names under this key
2369 struct btrfs_key key;
2375 btrfs_item_key_to_cpu(path->nodes[0], &key, i);
2376 if (key.objectid != ino || key.type != BTRFS_XATTR_ITEM_KEY) {
2417 search_key = key;
2568 struct btrfs_key key;
2587 btrfs_item_key_to_cpu(eb, &key, i);
2590 if (key.type == BTRFS_INODE_ITEM_KEY &&
2612 path, key.objectid);
2618 root, log, path, key.objectid, 0);
2623 eb, i, &key);
2639 inode = read_one_inode(root, key.objectid);
2659 path, key.objectid);
2667 if (key.type == BTRFS_DIR_INDEX_KEY &&
2670 eb, i, &key);
2679 if (key.type == BTRFS_XATTR_ITEM_KEY) {
2681 eb, i, &key);
2684 } else if (key.type == BTRFS_INODE_REF_KEY ||
2685 key.type == BTRFS_INODE_EXTREF_KEY) {
2687 eb, i, &key);
2691 } else if (key.type == BTRFS_EXTENT_DATA_KEY) {
2693 eb, i, &key);
2696 } else if (key.type == BTRFS_DIR_ITEM_KEY) {
2698 eb, i, &key);
3462 struct btrfs_key key;
3464 key.objectid = dir_ino;
3465 key.offset = 0;
3466 key.type = BTRFS_INODE_ITEM_KEY;
3469 ret = btrfs_search_slot(trans, log, &key, path, 0, 1);
3542 * last_offset tell us which parts of the key space the log should
3552 struct btrfs_key key;
3555 key.objectid = dirid;
3556 key.offset = first_offset;
3558 key.type = BTRFS_DIR_LOG_ITEM_KEY;
3560 key.type = BTRFS_DIR_LOG_INDEX_KEY;
3561 ret = btrfs_insert_empty_item(trans, log, path, &key, sizeof(*item));
3621 * create a range to tell us the last key of this type.
3635 /* go backward to find any previous key */
3654 * Find the first key from this transaction again. See the note for
3658 * search and this search we'll not find the key again and can just
3779 * key in the range logged that is not present in the log tree, then it means
3782 * In order for that scan to work, we must include one key smaller than
3783 * the smallest logged by this transaction and one key larger than the largest
3784 * key logged by this transaction.
3829 struct btrfs_key key;
3833 key.objectid = objectid;
3834 key.type = max_key_type;
3835 key.offset = (u64)-1;
3838 ret = btrfs_search_slot(trans, log, &key, path, -1, 1);
4251 struct btrfs_key key;
4268 key.objectid = btrfs_ino(inode);
4269 key.type = BTRFS_EXTENT_DATA_KEY;
4270 key.offset = em->start;
4272 ret = btrfs_insert_empty_item(trans, log, path, &key,
4331 struct btrfs_key key;
4346 key.objectid = ino;
4347 key.type = BTRFS_EXTENT_DATA_KEY;
4348 key.offset = i_size;
4349 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4376 btrfs_item_key_to_cpu(leaf, &key, slot);
4377 extent_end = key.offset +
4409 btrfs_item_key_to_cpu(leaf, &key, slot);
4410 if (key.objectid > ino)
4412 if (WARN_ON_ONCE(key.objectid < ino) ||
4413 key.type < BTRFS_EXTENT_DATA_KEY ||
4414 key.offset < i_size) {
4565 struct btrfs_key key;
4568 key.objectid = btrfs_ino(inode);
4569 key.type = BTRFS_INODE_ITEM_KEY;
4570 key.offset = 0;
4572 ret = btrfs_search_slot(NULL, log, &key, path, 0, 0);
4618 struct btrfs_key key;
4627 key.objectid = ino;
4628 key.type = BTRFS_XATTR_ITEM_KEY;
4629 key.offset = 0;
4631 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4656 btrfs_item_key_to_cpu(leaf, &key, slot);
4657 if (key.objectid != ino || key.type != BTRFS_XATTR_ITEM_KEY)
4695 struct btrfs_key key;
4704 key.objectid = ino;
4705 key.type = BTRFS_EXTENT_DATA_KEY;
4706 key.offset = 0;
4708 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4726 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
4727 if (key.objectid != ino || key.type != BTRFS_EXTENT_DATA_KEY)
4731 if (prev_extent_end < key.offset) {
4732 const u64 hole_len = key.offset - prev_extent_end;
4748 * Search for the same key again in the root. Since it's
4750 * key must still exist. If it doesn't just emit warning
4754 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4827 const struct btrfs_key *key,
4852 if (key->type == BTRFS_INODE_REF_KEY) {
4856 parent = key->offset;
4892 if (di_key.objectid != key->objectid) {
4943 struct btrfs_key key;
5037 key.objectid = ino;
5038 key.type = BTRFS_INODE_REF_KEY;
5039 key.offset = 0;
5040 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5063 btrfs_item_key_to_cpu(leaf, &key, slot);
5064 if (key.objectid != ino ||
5065 (key.type != BTRFS_INODE_REF_KEY &&
5066 key.type != BTRFS_INODE_EXTREF_KEY)) {
5071 ret = btrfs_check_ref_name_override(leaf, slot, &key,
5645 * names. This does not result in a problem because if a dir_item key is
5646 * logged but its matching dir_index key is not logged, at log replay time we
5648 * other hand if only the dir_index key ends up being logged, the respective
5793 struct btrfs_key key;
5803 key.objectid = ino;
5804 key.type = BTRFS_INODE_REF_KEY;
5805 key.offset = 0;
5806 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5826 btrfs_item_key_to_cpu(leaf, &key, slot);
5828 if (key.objectid != ino || key.type > BTRFS_INODE_EXTREF_KEY)
5840 if (key.type == BTRFS_INODE_EXTREF_KEY) {
5851 inode_key.objectid = key.offset;
6076 * Keep track of the last inode ref key and resume from that key
6272 struct btrfs_key key;
6304 key.objectid = BTRFS_TREE_LOG_OBJECTID;
6305 key.offset = (u64)-1;
6306 key.type = BTRFS_ROOT_ITEM_KEY;
6309 ret = btrfs_search_slot(NULL, log_root_tree, &key, path, 0, 0);
6399 key.offset = found_key.offset - 1;