xref: /openbmc/u-boot/fs/btrfs/super.c (revision 0bdea7c4) 
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * BTRFS filesystem implementation for U-Boot
4  *
5  * 2017 Marek Behun, CZ.NIC, marek.behun@nic.cz
6  */
7 
8 #include "btrfs.h"
9 
10 #define BTRFS_SUPER_FLAG_SUPP	(BTRFS_HEADER_FLAG_WRITTEN	\
11 				 | BTRFS_HEADER_FLAG_RELOC	\
12 				 | BTRFS_SUPER_FLAG_ERROR	\
13 				 | BTRFS_SUPER_FLAG_SEEDING	\
14 				 | BTRFS_SUPER_FLAG_METADUMP)
15 
16 #define BTRFS_SUPER_INFO_SIZE	4096
17 
18 /*
19  * checks if a valid root backup is present.
20  * considers the case when all root backups empty valid.
21  * returns -1 in case of invalid root backup and 0 for valid.
22  */
23 static int btrfs_check_super_roots(struct btrfs_super_block *sb)
24 {
25 	struct btrfs_root_backup *root_backup;
26 	int i, newest = -1;
27 	int num_empty = 0;
28 
29 	for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; ++i) {
30 		root_backup = sb->super_roots + i;
31 
32 		if (root_backup->tree_root == 0 && root_backup->tree_root_gen == 0)
33 			num_empty++;
34 
35 		if (root_backup->tree_root_gen == sb->generation)
36 			newest = i;
37 	}
38 
39 	if (num_empty == BTRFS_NUM_BACKUP_ROOTS) {
40 		return 0;
41 	} else if (newest >= 0) {
42 		return 0;
43 	}
44 
45 	return -1;
46 }
47 
48 static inline int is_power_of_2(u64 x)
49 {
50 	return !(x & (x - 1));
51 }
52 
53 static int btrfs_check_super_csum(char *raw_disk_sb)
54 {
55 	struct btrfs_super_block *disk_sb =
56 		(struct btrfs_super_block *) raw_disk_sb;
57 	u16 csum_type = le16_to_cpu(disk_sb->csum_type);
58 
59 	if (csum_type == BTRFS_CSUM_TYPE_CRC32) {
60 		u32 crc = ~(u32) 0;
61 		const int csum_size = sizeof(crc);
62 		char result[csum_size];
63 
64 		crc = btrfs_csum_data(raw_disk_sb + BTRFS_CSUM_SIZE, crc,
65 				      BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
66 		btrfs_csum_final(crc, result);
67 
68 		if (memcmp(raw_disk_sb, result, csum_size))
69 			return -1;
70 	} else {
71 		return -1;
72 	}
73 
74 	return 0;
75 }
76 
77 static int btrfs_check_super(struct btrfs_super_block *sb)
78 {
79 	int ret = 0;
80 
81 	if (sb->flags & ~BTRFS_SUPER_FLAG_SUPP) {
82 		printf("%s: Unsupported flags: %llu\n", __func__,
83 		       sb->flags & ~BTRFS_SUPER_FLAG_SUPP);
84 	}
85 
86 	if (sb->root_level > BTRFS_MAX_LEVEL) {
87 		printf("%s: tree_root level too big: %d >= %d\n", __func__,
88 		       sb->root_level, BTRFS_MAX_LEVEL);
89 		ret = -1;
90 	}
91 
92 	if (sb->chunk_root_level > BTRFS_MAX_LEVEL) {
93 		printf("%s: chunk_root level too big: %d >= %d\n", __func__,
94 		       sb->chunk_root_level, BTRFS_MAX_LEVEL);
95 		ret = -1;
96 	}
97 
98 	if (sb->log_root_level > BTRFS_MAX_LEVEL) {
99 		printf("%s: log_root level too big: %d >= %d\n", __func__,
100 		       sb->log_root_level, BTRFS_MAX_LEVEL);
101 		ret = -1;
102 	}
103 
104 	if (!is_power_of_2(sb->sectorsize) || sb->sectorsize < 4096 ||
105 	    sb->sectorsize > BTRFS_MAX_METADATA_BLOCKSIZE) {
106 		printf("%s: invalid sectorsize %u\n", __func__,
107 		       sb->sectorsize);
108 		ret = -1;
109 	}
110 
111 	if (!is_power_of_2(sb->nodesize) || sb->nodesize < sb->sectorsize ||
112 	    sb->nodesize > BTRFS_MAX_METADATA_BLOCKSIZE) {
113 		printf("%s: invalid nodesize %u\n", __func__, sb->nodesize);
114 		ret = -1;
115 	}
116 
117 	if (sb->nodesize != sb->__unused_leafsize) {
118 		printf("%s: invalid leafsize %u, should be %u\n", __func__,
119 		       sb->__unused_leafsize, sb->nodesize);
120 		ret = -1;
121 	}
122 
123 	if (!IS_ALIGNED(sb->root, sb->sectorsize)) {
124 		printf("%s: tree_root block unaligned: %llu\n", __func__,
125 		       sb->root);
126 		ret = -1;
127 	}
128 
129 	if (!IS_ALIGNED(sb->chunk_root, sb->sectorsize)) {
130 		printf("%s: chunk_root block unaligned: %llu\n", __func__,
131 		       sb->chunk_root);
132 		ret = -1;
133 	}
134 
135 	if (!IS_ALIGNED(sb->log_root, sb->sectorsize)) {
136 		printf("%s: log_root block unaligned: %llu\n", __func__,
137 		       sb->log_root);
138 		ret = -1;
139 	}
140 
141 	if (memcmp(sb->fsid, sb->dev_item.fsid, BTRFS_UUID_SIZE) != 0) {
142 		printf("%s: dev_item UUID does not match fsid\n", __func__);
143 		ret = -1;
144 	}
145 
146 	if (sb->bytes_used < 6*sb->nodesize) {
147 		printf("%s: bytes_used is too small %llu\n", __func__,
148 		       sb->bytes_used);
149 		ret = -1;
150 	}
151 
152 	if (!is_power_of_2(sb->stripesize)) {
153 		printf("%s: invalid stripesize %u\n", __func__, sb->stripesize);
154 		ret = -1;
155 	}
156 
157 	if (sb->sys_chunk_array_size > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) {
158 		printf("%s: system chunk array too big %u > %u\n", __func__,
159 		       sb->sys_chunk_array_size, BTRFS_SYSTEM_CHUNK_ARRAY_SIZE);
160 		ret = -1;
161 	}
162 
163 	if (sb->sys_chunk_array_size < sizeof(struct btrfs_key) +
164 	    sizeof(struct btrfs_chunk)) {
165 		printf("%s: system chunk array too small %u < %zu\n", __func__,
166 		       sb->sys_chunk_array_size, sizeof(struct btrfs_key)
167 		       + sizeof(struct btrfs_chunk));
168 		ret = -1;
169 	}
170 
171 	return ret;
172 }
173 
174 int btrfs_read_superblock(void)
175 {
176 	const u64 superblock_offsets[4] = {
177 		0x10000ull,
178 		0x4000000ull,
179 		0x4000000000ull,
180 		0x4000000000000ull
181 	};
182 	char raw_sb[BTRFS_SUPER_INFO_SIZE];
183 	struct btrfs_super_block *sb = (struct btrfs_super_block *) raw_sb;
184 	u64 dev_total_bytes;
185 	int i;
186 
187 	dev_total_bytes = (u64) btrfs_part_info->size * btrfs_part_info->blksz;
188 
189 	btrfs_info.sb.generation = 0;
190 
191 	for (i = 0; i < 4; ++i) {
192 		if (superblock_offsets[i] + sizeof(sb) > dev_total_bytes)
193 			break;
194 
195 		if (!btrfs_devread(superblock_offsets[i], BTRFS_SUPER_INFO_SIZE,
196 				   raw_sb))
197 			break;
198 
199 		if (btrfs_check_super_csum(raw_sb)) {
200 			printf("%s: invalid checksum at superblock mirror %i\n",
201 			       __func__, i);
202 			continue;
203 		}
204 
205 		btrfs_super_block_to_cpu(sb);
206 
207 		if (sb->magic != BTRFS_MAGIC) {
208 			printf("%s: invalid BTRFS magic 0x%016llX at "
209 			       "superblock mirror %i\n", __func__, sb->magic,
210 			       i);
211 		} else if (sb->bytenr != superblock_offsets[i]) {
212 			printf("%s: invalid bytenr 0x%016llX (expected "
213 			       "0x%016llX) at superblock mirror %i\n",
214 			       __func__, sb->bytenr, superblock_offsets[i], i);
215 		} else if (btrfs_check_super(sb)) {
216 			printf("%s: Checking superblock mirror %i failed\n",
217 			       __func__, i);
218 		} else if (sb->generation > btrfs_info.sb.generation) {
219 			memcpy(&btrfs_info.sb, sb, sizeof(*sb));
220 		} else {
221 			/* Nothing */
222 		}
223 	}
224 
225 	if (!btrfs_info.sb.generation) {
226 		printf("%s: No valid BTRFS superblock found!\n", __func__);
227 		return -1;
228 	}
229 
230 	if (btrfs_check_super_roots(&btrfs_info.sb)) {
231 		printf("%s: No valid root_backup found!\n", __func__);
232 		return -1;
233 	}
234 
235 	if (btrfs_info.sb.num_devices != 1) {
236 		printf("%s: Unsupported number of devices (%lli). This driver "
237 		       "only supports filesystem on one device.\n", __func__,
238 		       btrfs_info.sb.num_devices);
239 		return -1;
240 	}
241 
242 	debug("Chosen superblock with generation = %llu\n",
243 	      btrfs_info.sb.generation);
244 
245 	return 0;
246 }
247