[linux.git] / fs / btrfs / uuid-tree.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) STRATO AG 2013.  All rights reserved.
 */

#include <linux/uuid.h>
#include <asm/unaligned.h>
#include "ctree.h"
#include "transaction.h"
#include "disk-io.h"
#include "print-tree.h"


static void btrfs_uuid_to_key(u8 *uuid, u8 type, struct btrfs_key *key)
{
	key->type = type;
	key->objectid = get_unaligned_le64(uuid);
	key->offset = get_unaligned_le64(uuid + sizeof(u64));
}

/* return -ENOENT for !found, < 0 for errors, or 0 if an item was found */
static int btrfs_uuid_tree_lookup(struct btrfs_root *uuid_root, u8 *uuid,
				  u8 type, u64 subid)
{
	int ret;
	struct btrfs_path *path = NULL;
	struct extent_buffer *eb;
	int slot;
	u32 item_size;
	unsigned long offset;
	struct btrfs_key key;

	if (WARN_ON_ONCE(!uuid_root)) {
		ret = -ENOENT;
		goto out;
	}

	path = btrfs_alloc_path();
	if (!path) {
		ret = -ENOMEM;
		goto out;
	}

	btrfs_uuid_to_key(uuid, type, &key);
	ret = btrfs_search_slot(NULL, uuid_root, &key, path, 0, 0);
	if (ret < 0) {
		goto out;
	} else if (ret > 0) {
		ret = -ENOENT;
		goto out;
	}

	eb = path->nodes[0];
	slot = path->slots[0];
	item_size = btrfs_item_size_nr(eb, slot);
	offset = btrfs_item_ptr_offset(eb, slot);
	ret = -ENOENT;

	if (!IS_ALIGNED(item_size, sizeof(u64))) {
		btrfs_warn(uuid_root->fs_info,
			   "uuid item with illegal size %lu!",
			   (unsigned long)item_size);
		goto out;
	}
	while (item_size) {
		__le64 data;

		read_extent_buffer(eb, &data, offset, sizeof(data));
		if (le64_to_cpu(data) == subid) {
			ret = 0;
			break;
		}
		offset += sizeof(data);
		item_size -= sizeof(data);
	}

out:
	btrfs_free_path(path);
	return ret;
}

int btrfs_uuid_tree_add(struct btrfs_trans_handle *trans, u8 *uuid, u8 type,
			u64 subid_cpu)
{
	struct btrfs_fs_info *fs_info = trans->fs_info;
	struct btrfs_root *uuid_root = fs_info->uuid_root;
	int ret;
	struct btrfs_path *path = NULL;
	struct btrfs_key key;
	struct extent_buffer *eb;
	int slot;
	unsigned long offset;
	__le64 subid_le;

	ret = btrfs_uuid_tree_lookup(uuid_root, uuid, type, subid_cpu);
	if (ret != -ENOENT)
		return ret;

	if (WARN_ON_ONCE(!uuid_root)) {
		ret = -EINVAL;
		goto out;
	}

	btrfs_uuid_to_key(uuid, type, &key);

	path = btrfs_alloc_path();
	if (!path) {
		ret = -ENOMEM;
		goto out;
	}

	ret = btrfs_insert_empty_item(trans, uuid_root, path, &key,
				      sizeof(subid_le));
	if (ret >= 0) {
		/* Add an item for the type for the first time */
		eb = path->nodes[0];
		slot = path->slots[0];
		offset = btrfs_item_ptr_offset(eb, slot);
	} else if (ret == -EEXIST) {
		/*
		 * An item with that type already exists.
		 * Extend the item and store the new subid at the end.
		 */
		btrfs_extend_item(fs_info, path, sizeof(subid_le));
		eb = path->nodes[0];
		slot = path->slots[0];
		offset = btrfs_item_ptr_offset(eb, slot);
		offset += btrfs_item_size_nr(eb, slot) - sizeof(subid_le);
	} else if (ret < 0) {
		btrfs_warn(fs_info,
			   "insert uuid item failed %d (0x%016llx, 0x%016llx) type %u!",
			   ret, (unsigned long long)key.objectid,
			   (unsigned long long)key.offset, type);
		goto out;
	}

	ret = 0;
	subid_le = cpu_to_le64(subid_cpu);
	write_extent_buffer(eb, &subid_le, offset, sizeof(subid_le));
	btrfs_mark_buffer_dirty(eb);

out:
	btrfs_free_path(path);
	return ret;
}

int btrfs_uuid_tree_remove(struct btrfs_trans_handle *trans, u8 *uuid, u8 type,
			u64 subid)
{
	struct btrfs_fs_info *fs_info = trans->fs_info;
	struct btrfs_root *uuid_root = fs_info->uuid_root;
	int ret;
	struct btrfs_path *path = NULL;
	struct btrfs_key key;
	struct extent_buffer *eb;
	int slot;
	unsigned long offset;
	u32 item_size;
	unsigned long move_dst;
	unsigned long move_src;
	unsigned long move_len;

	if (WARN_ON_ONCE(!uuid_root)) {
		ret = -EINVAL;
		goto out;
	}

	btrfs_uuid_to_key(uuid, type, &key);

	path = btrfs_alloc_path();
	if (!path) {
		ret = -ENOMEM;
		goto out;
	}

	ret = btrfs_search_slot(trans, uuid_root, &key, path, -1, 1);
	if (ret < 0) {
		btrfs_warn(fs_info, "error %d while searching for uuid item!",
			   ret);
		goto out;
	}
	if (ret > 0) {
		ret = -ENOENT;
		goto out;
	}

	eb = path->nodes[0];
	slot = path->slots[0];
	offset = btrfs_item_ptr_offset(eb, slot);
	item_size = btrfs_item_size_nr(eb, slot);
	if (!IS_ALIGNED(item_size, sizeof(u64))) {
		btrfs_warn(fs_info, "uuid item with illegal size %lu!",
			   (unsigned long)item_size);
		ret = -ENOENT;
		goto out;
	}
	while (item_size) {
		__le64 read_subid;

		read_extent_buffer(eb, &read_subid, offset, sizeof(read_subid));
		if (le64_to_cpu(read_subid) == subid)
			break;
		offset += sizeof(read_subid);
		item_size -= sizeof(read_subid);
	}

	if (!item_size) {
		ret = -ENOENT;
		goto out;
	}

	item_size = btrfs_item_size_nr(eb, slot);
	if (item_size == sizeof(subid)) {
		ret = btrfs_del_item(trans, uuid_root, path);
		goto out;
	}

	move_dst = offset;
	move_src = offset + sizeof(subid);
	move_len = item_size - (move_src - btrfs_item_ptr_offset(eb, slot));
	memmove_extent_buffer(eb, move_dst, move_src, move_len);
	btrfs_truncate_item(fs_info, path, item_size - sizeof(subid), 1);

out:
	btrfs_free_path(path);
	return ret;
}

static int btrfs_uuid_iter_rem(struct btrfs_root *uuid_root, u8 *uuid, u8 type,
			       u64 subid)
{
	struct btrfs_trans_handle *trans;
	int ret;

	/* 1 - for the uuid item */
	trans = btrfs_start_transaction(uuid_root, 1);
	if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		goto out;
	}

	ret = btrfs_uuid_tree_remove(trans, uuid, type, subid);
	btrfs_end_transaction(trans);

out:
	return ret;
}

int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info,
			    int (*check_func)(struct btrfs_fs_info *, u8 *, u8,
					      u64))
{
	struct btrfs_root *root = fs_info->uuid_root;
	struct btrfs_key key;
	struct btrfs_path *path;
	int ret = 0;
	struct extent_buffer *leaf;
	int slot;
	u32 item_size;
	unsigned long offset;

	path = btrfs_alloc_path();
	if (!path) {
		ret = -ENOMEM;
		goto out;
	}

	key.objectid = 0;
	key.type = 0;
	key.offset = 0;

again_search_slot:
	ret = btrfs_search_forward(root, &key, path, BTRFS_OLDEST_GENERATION);
	if (ret) {
		if (ret > 0)
			ret = 0;
		goto out;
	}

	while (1) {
		cond_resched();
		leaf = path->nodes[0];
		slot = path->slots[0];
		btrfs_item_key_to_cpu(leaf, &key, slot);

		if (key.type != BTRFS_UUID_KEY_SUBVOL &&
		    key.type != BTRFS_UUID_KEY_RECEIVED_SUBVOL)
			goto skip;

		offset = btrfs_item_ptr_offset(leaf, slot);
		item_size = btrfs_item_size_nr(leaf, slot);
		if (!IS_ALIGNED(item_size, sizeof(u64))) {
			btrfs_warn(fs_info,
				   "uuid item with illegal size %lu!",
				   (unsigned long)item_size);
			goto skip;
		}
		while (item_size) {
			u8 uuid[BTRFS_UUID_SIZE];
			__le64 subid_le;
			u64 subid_cpu;

			put_unaligned_le64(key.objectid, uuid);
			put_unaligned_le64(key.offset, uuid + sizeof(u64));
			read_extent_buffer(leaf, &subid_le, offset,
					   sizeof(subid_le));
			subid_cpu = le64_to_cpu(subid_le);
			ret = check_func(fs_info, uuid, key.type, subid_cpu);
			if (ret < 0)
				goto out;
			if (ret > 0) {
				btrfs_release_path(path);
				ret = btrfs_uuid_iter_rem(root, uuid, key.type,
							  subid_cpu);
				if (ret == 0) {
					/*
					 * this might look inefficient, but the
					 * justification is that it is an
					 * exception that check_func returns 1,
					 * and that in the regular case only one
					 * entry per UUID exists.
					 */
					goto again_search_slot;
				}
				if (ret < 0 && ret != -ENOENT)
					goto out;
			}
			item_size -= sizeof(subid_le);
			offset += sizeof(subid_le);
		}

skip:
		ret = btrfs_next_item(root, path);
		if (ret == 0)
			continue;
		else if (ret > 0)
			ret = 0;
		break;
	}

out:
	btrfs_free_path(path);
	return ret;
}
Commit	Line	Data
c1d7c514	1	// SPDX-License-Identifier: GPL-2.0
07b30a49 SB	2	/*
07b30a49 SB	3	* Copyright (C) STRATO AG 2013. All rights reserved.
07b30a49	4	*/
c1d7c514	5
07b30a49 SB	6	#include <linux/uuid.h>
	7	#include <asm/unaligned.h>
	8	#include "ctree.h"
	9	#include "transaction.h"
	10	#include "disk-io.h"
	11	#include "print-tree.h"
	12
	13
	14	static void btrfs_uuid_to_key(u8 uuid, u8 type, struct btrfs_key key)
	15	{
	16	key->type = type;
	17	key->objectid = get_unaligned_le64(uuid);
	18	key->offset = get_unaligned_le64(uuid + sizeof(u64));
	19	}
	20
	21	/* return -ENOENT for !found, < 0 for errors, or 0 if an item was found */
	22	static int btrfs_uuid_tree_lookup(struct btrfs_root uuid_root, u8 uuid,
	23	u8 type, u64 subid)
	24	{
	25	int ret;
	26	struct btrfs_path *path = NULL;
	27	struct extent_buffer *eb;
	28	int slot;
	29	u32 item_size;
	30	unsigned long offset;
	31	struct btrfs_key key;
	32
	33	if (WARN_ON_ONCE(!uuid_root)) {
	34	ret = -ENOENT;
	35	goto out;
	36	}
	37
	38	path = btrfs_alloc_path();
	39	if (!path) {
	40	ret = -ENOMEM;
	41	goto out;
	42	}
	43
	44	btrfs_uuid_to_key(uuid, type, &key);
	45	ret = btrfs_search_slot(NULL, uuid_root, &key, path, 0, 0);
	46	if (ret < 0) {
	47	goto out;
	48	} else if (ret > 0) {
	49	ret = -ENOENT;
	50	goto out;
	51	}
	52
	53	eb = path->nodes[0];
	54	slot = path->slots[0];
	55	item_size = btrfs_item_size_nr(eb, slot);
	56	offset = btrfs_item_ptr_offset(eb, slot);
	57	ret = -ENOENT;
	58
	59	if (!IS_ALIGNED(item_size, sizeof(u64))) {
5d163e0e JM	60	btrfs_warn(uuid_root->fs_info,
	61	"uuid item with illegal size %lu!",
	62	(unsigned long)item_size);
07b30a49 SB	63	goto out;
	64	}
	65	while (item_size) {
	66	__le64 data;
	67
	68	read_extent_buffer(eb, &data, offset, sizeof(data));
	69	if (le64_to_cpu(data) == subid) {
	70	ret = 0;
	71	break;
	72	}
	73	offset += sizeof(data);
	74	item_size -= sizeof(data);
	75	}
	76
	77	out:
	78	btrfs_free_path(path);
	79	return ret;
	80	}
	81
cdb345a8	82	int btrfs_uuid_tree_add(struct btrfs_trans_handle trans, u8 uuid, u8 type,
07b30a49 SB	83	u64 subid_cpu)
07b30a49 SB	84	{
cdb345a8	85	struct btrfs_fs_info *fs_info = trans->fs_info;
6bccf3ab	86	struct btrfs_root *uuid_root = fs_info->uuid_root;
07b30a49 SB	87	int ret;
	88	struct btrfs_path *path = NULL;
	89	struct btrfs_key key;
	90	struct extent_buffer *eb;
	91	int slot;
	92	unsigned long offset;
	93	__le64 subid_le;
	94
	95	ret = btrfs_uuid_tree_lookup(uuid_root, uuid, type, subid_cpu);
	96	if (ret != -ENOENT)
	97	return ret;
	98
	99	if (WARN_ON_ONCE(!uuid_root)) {
	100	ret = -EINVAL;
	101	goto out;
	102	}
	103
	104	btrfs_uuid_to_key(uuid, type, &key);
	105
	106	path = btrfs_alloc_path();
	107	if (!path) {
	108	ret = -ENOMEM;
	109	goto out;
	110	}
	111
	112	ret = btrfs_insert_empty_item(trans, uuid_root, path, &key,
	113	sizeof(subid_le));
	114	if (ret >= 0) {
	115	/* Add an item for the type for the first time */
	116	eb = path->nodes[0];
	117	slot = path->slots[0];
	118	offset = btrfs_item_ptr_offset(eb, slot);
	119	} else if (ret == -EEXIST) {
	120	/*
	121	* An item with that type already exists.
	122	* Extend the item and store the new subid at the end.
	123	*/
2ff7e61e	124	btrfs_extend_item(fs_info, path, sizeof(subid_le));
07b30a49 SB	125	eb = path->nodes[0];
	126	slot = path->slots[0];
	127	offset = btrfs_item_ptr_offset(eb, slot);
	128	offset += btrfs_item_size_nr(eb, slot) - sizeof(subid_le);
	129	} else if (ret < 0) {
6bccf3ab	130	btrfs_warn(fs_info,
5d163e0e JM	131	"insert uuid item failed %d (0x%016llx, 0x%016llx) type %u!",
	132	ret, (unsigned long long)key.objectid,
	133	(unsigned long long)key.offset, type);
07b30a49 SB	134	goto out;
	135	}
	136
	137	ret = 0;
	138	subid_le = cpu_to_le64(subid_cpu);
	139	write_extent_buffer(eb, &subid_le, offset, sizeof(subid_le));
	140	btrfs_mark_buffer_dirty(eb);
	141
	142	out:
	143	btrfs_free_path(path);
	144	return ret;
	145	}
	146
d1957791	147	int btrfs_uuid_tree_remove(struct btrfs_trans_handle trans, u8 uuid, u8 type,
07b30a49 SB	148	u64 subid)
07b30a49 SB	149	{
d1957791	150	struct btrfs_fs_info *fs_info = trans->fs_info;
6bccf3ab	151	struct btrfs_root *uuid_root = fs_info->uuid_root;
07b30a49 SB	152	int ret;
	153	struct btrfs_path *path = NULL;
	154	struct btrfs_key key;
	155	struct extent_buffer *eb;
	156	int slot;
	157	unsigned long offset;
	158	u32 item_size;
	159	unsigned long move_dst;
	160	unsigned long move_src;
	161	unsigned long move_len;
	162
	163	if (WARN_ON_ONCE(!uuid_root)) {
	164	ret = -EINVAL;
	165	goto out;
	166	}
	167
	168	btrfs_uuid_to_key(uuid, type, &key);
	169
	170	path = btrfs_alloc_path();
	171	if (!path) {
	172	ret = -ENOMEM;
	173	goto out;
	174	}
	175
	176	ret = btrfs_search_slot(trans, uuid_root, &key, path, -1, 1);
	177	if (ret < 0) {
0b246afa JM	178	btrfs_warn(fs_info, "error %d while searching for uuid item!",
0b246afa JM	179	ret);
07b30a49 SB	180	goto out;
	181	}
	182	if (ret > 0) {
	183	ret = -ENOENT;
	184	goto out;
	185	}
	186
	187	eb = path->nodes[0];
	188	slot = path->slots[0];
	189	offset = btrfs_item_ptr_offset(eb, slot);
	190	item_size = btrfs_item_size_nr(eb, slot);
	191	if (!IS_ALIGNED(item_size, sizeof(u64))) {
0b246afa	192	btrfs_warn(fs_info, "uuid item with illegal size %lu!",
5d163e0e	193	(unsigned long)item_size);
07b30a49 SB	194	ret = -ENOENT;
	195	goto out;
	196	}
	197	while (item_size) {
	198	__le64 read_subid;
	199
	200	read_extent_buffer(eb, &read_subid, offset, sizeof(read_subid));
	201	if (le64_to_cpu(read_subid) == subid)
	202	break;
	203	offset += sizeof(read_subid);
	204	item_size -= sizeof(read_subid);
	205	}
	206
	207	if (!item_size) {
	208	ret = -ENOENT;
	209	goto out;
	210	}
	211
	212	item_size = btrfs_item_size_nr(eb, slot);
	213	if (item_size == sizeof(subid)) {
	214	ret = btrfs_del_item(trans, uuid_root, path);
	215	goto out;
	216	}
	217
	218	move_dst = offset;
	219	move_src = offset + sizeof(subid);
	220	move_len = item_size - (move_src - btrfs_item_ptr_offset(eb, slot));
	221	memmove_extent_buffer(eb, move_dst, move_src, move_len);
2ff7e61e	222	btrfs_truncate_item(fs_info, path, item_size - sizeof(subid), 1);
07b30a49 SB	223
	224	out:
	225	btrfs_free_path(path);
	226	return ret;
	227	}
70f80175 SB	228
	229	static int btrfs_uuid_iter_rem(struct btrfs_root uuid_root, u8 uuid, u8 type,
	230	u64 subid)
	231	{
	232	struct btrfs_trans_handle *trans;
	233	int ret;
	234
	235	/* 1 - for the uuid item */
	236	trans = btrfs_start_transaction(uuid_root, 1);
	237	if (IS_ERR(trans)) {
	238	ret = PTR_ERR(trans);
	239	goto out;
	240	}
	241
d1957791	242	ret = btrfs_uuid_tree_remove(trans, uuid, type, subid);
3a45bb20	243	btrfs_end_transaction(trans);
70f80175 SB	244
	245	out:
	246	return ret;
	247	}
	248
	249	int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info,
	250	int (check_func)(struct btrfs_fs_info , u8 *, u8,
	251	u64))
	252	{
	253	struct btrfs_root *root = fs_info->uuid_root;
	254	struct btrfs_key key;
70f80175 SB	255	struct btrfs_path *path;
	256	int ret = 0;
	257	struct extent_buffer *leaf;
	258	int slot;
	259	u32 item_size;
	260	unsigned long offset;
	261
	262	path = btrfs_alloc_path();
	263	if (!path) {
	264	ret = -ENOMEM;
	265	goto out;
	266	}
	267
	268	key.objectid = 0;
	269	key.type = 0;
	270	key.offset = 0;
70f80175 SB	271
70f80175 SB	272	again_search_slot:
7c829b72	273	ret = btrfs_search_forward(root, &key, path, BTRFS_OLDEST_GENERATION);
70f80175 SB	274	if (ret) {
	275	if (ret > 0)
	276	ret = 0;
	277	goto out;
	278	}
	279
	280	while (1) {
	281	cond_resched();
	282	leaf = path->nodes[0];
	283	slot = path->slots[0];
	284	btrfs_item_key_to_cpu(leaf, &key, slot);
	285
	286	if (key.type != BTRFS_UUID_KEY_SUBVOL &&
	287	key.type != BTRFS_UUID_KEY_RECEIVED_SUBVOL)
	288	goto skip;
	289
	290	offset = btrfs_item_ptr_offset(leaf, slot);
	291	item_size = btrfs_item_size_nr(leaf, slot);
	292	if (!IS_ALIGNED(item_size, sizeof(u64))) {
5d163e0e JM	293	btrfs_warn(fs_info,
	294	"uuid item with illegal size %lu!",
	295	(unsigned long)item_size);
70f80175 SB	296	goto skip;
	297	}
	298	while (item_size) {
	299	u8 uuid[BTRFS_UUID_SIZE];
	300	__le64 subid_le;
	301	u64 subid_cpu;
	302
	303	put_unaligned_le64(key.objectid, uuid);
	304	put_unaligned_le64(key.offset, uuid + sizeof(u64));
	305	read_extent_buffer(leaf, &subid_le, offset,
	306	sizeof(subid_le));
	307	subid_cpu = le64_to_cpu(subid_le);
	308	ret = check_func(fs_info, uuid, key.type, subid_cpu);
	309	if (ret < 0)
	310	goto out;
	311	if (ret > 0) {
	312	btrfs_release_path(path);
	313	ret = btrfs_uuid_iter_rem(root, uuid, key.type,
	314	subid_cpu);
	315	if (ret == 0) {
	316	/*
	317	* this might look inefficient, but the
	318	* justification is that it is an
	319	* exception that check_func returns 1,
	320	* and that in the regular case only one
	321	* entry per UUID exists.
	322	*/
	323	goto again_search_slot;
	324	}
	325	if (ret < 0 && ret != -ENOENT)
	326	goto out;
	327	}
	328	item_size -= sizeof(subid_le);
	329	offset += sizeof(subid_le);
	330	}
	331
	332	skip:
	333	ret = btrfs_next_item(root, path);
	334	if (ret == 0)
	335	continue;
	336	else if (ret > 0)
	337	ret = 0;
	338	break;
	339	}
	340
	341	out:
	342	btrfs_free_path(path);
73ba39ab	343	return ret;
70f80175	344	}