fs/btrfs/extent-tree.c

62 			 struct btrfs_key *key);
74 	struct btrfs_key key;
81 	key.objectid = start;
82 	key.offset = len;
83 	key.type = BTRFS_EXTENT_ITEM_KEY;
84 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
109 	struct btrfs_key key;
135 	key.objectid = bytenr;
136 	key.offset = offset;
138 		key.type = BTRFS_METADATA_ITEM_KEY;
140 		key.type = BTRFS_EXTENT_ITEM_KEY;
143 	ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
147 	if (ret > 0 && metadata && key.type == BTRFS_METADATA_ITEM_KEY) {
150 			btrfs_item_key_to_cpu(path->nodes[0], &key,
152 			if (key.objectid == bytenr &&
153 			    key.type == BTRFS_EXTENT_ITEM_KEY &&
154 			    key.offset == fs_info->nodesize)
252  * and the pointer's key. These information allow us to find the block by
289  * The key objectid corresponds to the first byte in the extent,
290  * The key type is used to differentiate between types of back refs.
291  * There are different meanings of the key offset for different types
307  * The key offset for the implicit back refs is hash of the first
314  * The key offset for the implicit back refs is the first byte of
332  * only consist of key. The key offset for the implicit back refs is
333  * objectid of block's owner tree. The key offset for the full back refs
336  * When implicit back refs is used, information about the lowest key and
445 	struct btrfs_key key;
452 	key.objectid = bytenr;
454 		key.type = BTRFS_SHARED_DATA_REF_KEY;
455 		key.offset = parent;
457 		key.type = BTRFS_EXTENT_DATA_REF_KEY;
458 		key.offset = hash_extent_data_ref(root_objectid,
463 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
490 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
491 		if (key.objectid != bytenr ||
492 		    key.type != BTRFS_EXTENT_DATA_REF_KEY)
519 	struct btrfs_key key;
527 	key.objectid = bytenr;
529 		key.type = BTRFS_SHARED_DATA_REF_KEY;
530 		key.offset = node->parent;
533 		key.type = BTRFS_EXTENT_DATA_REF_KEY;
534 		key.offset = hash_extent_data_ref(node->ref_root, owner, offset);
538 	ret = btrfs_insert_empty_item(trans, root, path, &key, size);
563 			key.offset++;
564 			ret = btrfs_insert_empty_item(trans, root, path, &key,
596 	struct btrfs_key key;
604 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
606 	if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
610 	} else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
616 			  "unrecognized backref key (%llu %u %llu)",
617 			  key.objectid, key.type, key.offset);
628 		if (key.type == BTRFS_EXTENT_DATA_REF_KEY)
630 		else if (key.type == BTRFS_SHARED_DATA_REF_KEY)
640 	struct btrfs_key key;
648 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
664 	} else if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
668 	} else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
684 	struct btrfs_key key;
687 	key.objectid = bytenr;
689 		key.type = BTRFS_SHARED_BLOCK_REF_KEY;
690 		key.offset = parent;
692 		key.type = BTRFS_TREE_BLOCK_REF_KEY;
693 		key.offset = root_objectid;
696 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
708 	struct btrfs_key key;
711 	key.objectid = bytenr;
713 		key.type = BTRFS_SHARED_BLOCK_REF_KEY;
714 		key.offset = node->parent;
716 		key.type = BTRFS_TREE_BLOCK_REF_KEY;
717 		key.offset = node->ref_root;
720 	ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
743 			 struct btrfs_key *key)
753 			btrfs_item_key_to_cpu(path->nodes[level], key,
756 			btrfs_node_key_to_cpu(path->nodes[level], key,
786 	struct btrfs_key key;
801 	key.objectid = bytenr;
802 	key.type = BTRFS_EXTENT_ITEM_KEY;
803 	key.offset = num_bytes;
818 		key.type = BTRFS_METADATA_ITEM_KEY;
819 		key.offset = owner;
823 	ret = btrfs_search_slot(trans, root, &key, path, extra_size, 1);
835 			btrfs_item_key_to_cpu(path->nodes[0], &key,
837 			if (key.objectid == bytenr &&
838 			    key.type == BTRFS_EXTENT_ITEM_KEY &&
839 			    key.offset == num_bytes)
843 			key.objectid = bytenr;
844 			key.type = BTRFS_EXTENT_ITEM_KEY;
845 			key.offset = num_bytes;
966 		if (find_next_key(path, 0, &key) == 0 &&
967 		    key.objectid == bytenr &&
968 		    key.type < BTRFS_BLOCK_GROUP_ITEM_KEY) {
1099 		struct btrfs_key key;
1102 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1103 		if (key.type == BTRFS_METADATA_ITEM_KEY)
1106 			extent_size = key.offset;
1110 			  key.objectid, extent_size, refs_to_mod, refs);
1143 			struct btrfs_key key;
1145 			btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1150 				  key.objectid, refs_to_mod);
1156 		struct btrfs_key key;
1159 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1160 		if (key.type == BTRFS_METADATA_ITEM_KEY)
1163 			extent_size = key.offset;
1167 			  (unsigned long)iref, key.objectid, extent_size,
1472 	struct btrfs_key key;
1498 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1554 		struct btrfs_key key;
1568 		key.objectid = node->bytenr;
1569 		key.type = BTRFS_EXTENT_ITEM_KEY;
1570 		key.offset = node->num_bytes;
1573 						 flags, owner, offset, &key,
1603 		btrfs_set_tree_block_key(leaf, bi, &extent_op->key);
1613 	struct btrfs_key key;
1631 	key.objectid = head->bytenr;
1634 		key.type = BTRFS_METADATA_ITEM_KEY;
1635 		key.offset = extent_op->level;
1637 		key.type = BTRFS_EXTENT_ITEM_KEY;
1638 		key.offset = head->num_bytes;
1641 	root = btrfs_extent_root(fs_info, key.objectid);
1643 	ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
1650 				btrfs_item_key_to_cpu(path->nodes[0], &key,
1652 				if (key.objectid == head->bytenr &&
1653 				    key.type == BTRFS_EXTENT_ITEM_KEY &&
1654 				    key.offset == head->num_bytes)
1661 				key.objectid = head->bytenr;
1662 				key.offset = head->num_bytes;
1663 				key.type = BTRFS_EXTENT_ITEM_KEY;
2353 	struct btrfs_key key;
2359 	key.objectid = bytenr;
2360 	key.offset = (u64)-1;
2361 	key.type = BTRFS_EXTENT_ITEM_KEY;
2363 	ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
2381 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2383 	if (key.objectid != bytenr || key.type != BTRFS_EXTENT_ITEM_KEY)
2464 	struct btrfs_key key;
2499 			btrfs_item_key_to_cpu(buf, &key, i);
2500 			if (key.type != BTRFS_EXTENT_DATA_KEY)
2514 			key.offset -= btrfs_file_extent_offset(buf, fi);
2515 			btrfs_init_data_ref(&ref, key.objectid, key.offset,
2679 	struct btrfs_key key;
2688 		btrfs_item_key_to_cpu(eb, &key, i);
2689 		if (key.type != BTRFS_EXTENT_DATA_KEY)
2697 		key.objectid = btrfs_file_extent_disk_bytenr(eb, item);
2698 		key.offset = btrfs_file_extent_disk_num_bytes(eb, item);
2699 		ret = __exclude_logged_extent(fs_info, key.objectid, key.offset);
3021  * 	item 0 key (13631488 EXTENT_ITEM 1048576) itemoff 16201 itemsize 82
3037  * 	item 0 key (13631488 EXTENT_ITEM 1048576) itemoff 16201 itemsize 82
3045  *	item 0 key (13631488 EXTENT_ITEM 1048576) itemoff 3971 itemsize 24
3048  *	item 2 key (13631488 EXTENT_DATA_REF <HASH>) itemoff 3915 itemsize 28
3062  *	item 0 key (13631488 EXTENT_ITEM 1048576) itemoff 3971 itemsize 24
3073 	struct btrfs_key key;
3128 			btrfs_item_key_to_cpu(path->nodes[0], &key,
3130 			if (key.objectid != bytenr)
3132 			if (key.type == BTRFS_EXTENT_ITEM_KEY &&
3133 			    key.offset == num_bytes) {
3137 			if (key.type == BTRFS_METADATA_ITEM_KEY &&
3138 			    key.offset == owner_objectid) {
3167 			key.objectid = bytenr;
3168 			key.type = BTRFS_EXTENT_ITEM_KEY;
3169 			key.offset = num_bytes;
3172 				key.type = BTRFS_METADATA_ITEM_KEY;
3173 				key.offset = owner_objectid;
3177 						&key, path, -1, 1);
3184 				btrfs_item_key_to_cpu(path->nodes[0], &key,
3186 				if (key.objectid == bytenr &&
3187 				    key.type == BTRFS_EXTENT_ITEM_KEY &&
3188 				    key.offset == num_bytes)
3194 				key.objectid = bytenr;
3195 				key.type = BTRFS_EXTENT_ITEM_KEY;
3196 				key.offset = num_bytes;
3199 							&key, path, -1, 1);
3239 	    key.type == BTRFS_EXTENT_ITEM_KEY) {
3244 "invalid extent item size for key (%llu, %u, %llu) slot %u owner %llu, has %u expect >= %zu",
3245 				       key.objectid, key.type, key.offset,
3315 "invalid iref, extent item key (%llu %u %llu) slot %u doesn't have wanted iref",
3316 						       key.objectid, key.type,
3317 						       key.offset, path->slots[0]);
4340  * The key ins is changed to record the hole:
4644  * @ins            -	This key is modified to record the found hole. It will
4907 		btrfs_set_tree_block_key(leaf, block_info, &extent_op->key);
5114 					     const struct btrfs_disk_key *key,
5180 		if (key)
5181 			memcpy(&extent_op->key, key, sizeof(extent_op->key));
5183 			memset(&extent_op->key, 0, sizeof(extent_op->key));
5239 	struct btrfs_key key;
5291 			btrfs_node_key_to_cpu(eb, &key, slot);
5292 			ret = btrfs_comp_cpu_keys(&key,
5385  * would have a drop_progress key that hadn't been updated properly.
5433 	struct btrfs_key key;
5497 			btrfs_node_key_to_cpu(path->nodes[level], &key,
5499 			ret = btrfs_comp_cpu_keys(&key, &wc->update_progress);
5604 		 * We need to update the next key in our walk control so we can
5605 		 * update the drop_progress key accordingly.  We don't care if
5606 		 * find_next_key doesn't find a key because that means we're at
5835 	struct btrfs_key key;
5893 		btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
5894 		memcpy(&wc->update_progress, &key,
5900 		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);