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