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