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