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