fs/btrfs/super.c

   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 }