super-recover.c

   1 /*
   2  * Copyright (C) 2013 FUJITSU LIMITED.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public
   6  * License v2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public
  14  * License along with this program; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 021110-1307, USA.
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <fcntl.h>
  22 #include <sys/stat.h>
  23 #include <uuid/uuid.h>
  24 #include <errno.h>
  25 #include <unistd.h>
  26 #include <ctype.h>
  27 #include <getopt.h>
  28
  29 #include "kerncompat.h"
  30 #include "ctree.h"
  31 #include "disk-io.h"
  32 #include "list.h"
  33 #include "utils.h"
  34 #include "crc32c.h"
  35 #include "volumes.h"
  36 #include "commands.h"
  37
  38 struct btrfs_recover_superblock {
  39         struct btrfs_fs_devices *fs_devices;
  40
  41         struct list_head good_supers;
  42         struct list_head bad_supers;
  43
  44         u64 max_generation;
  45 };
  46
  47 struct super_block_record {
  48         struct list_head list;
  49
  50         char *device_name;
  51         struct btrfs_super_block sb;
  52
  53         u64 bytenr;
  54 };
  55
  56 static
  57 void init_recover_superblock(struct btrfs_recover_superblock *recover)
  58 {
  59         INIT_LIST_HEAD(&recover->good_supers);
  60         INIT_LIST_HEAD(&recover->bad_supers);
  61
  62         recover->fs_devices = NULL;
  63         recover->max_generation = 0;
  64 }
  65
  66 static
  67 void free_recover_superblock(struct btrfs_recover_superblock *recover)
  68 {
  69         struct super_block_record *record;
  70
  71         if (!recover->fs_devices)
  72                 return;
  73
  74         while (!list_empty(&recover->good_supers)) {
  75                 record = list_entry(recover->good_supers.next,
  76                                 struct super_block_record, list);
  77                 list_del_init(&record->list);
  78                 free(record->device_name);
  79                 free(record);
  80         }
  81
  82         while (!list_empty(&recover->bad_supers)) {
  83                 record = list_entry(recover->bad_supers.next,
  84                                 struct super_block_record, list);
  85                 list_del_init(&record->list);
  86                 free(record->device_name);
  87                 free(record);
  88         }
  89 }
  90
  91 static int add_superblock_record(struct btrfs_super_block *sb, char *fname,
  92                         u64 bytenr, struct list_head *head)
  93 {
  94         struct super_block_record *record;
  95
  96         record = malloc(sizeof(struct super_block_record));
  97         if (!record)
  98                 return -ENOMEM;
  99
 100         record->device_name = strdup(fname);
 101         if (!record->device_name) {
 102                 free(record);
 103                 return -ENOMEM;
 104         }
 105         memcpy(&record->sb, sb, sizeof(*sb));
 106         record->bytenr = bytenr;
 107         list_add_tail(&record->list, head);
 108
 109         return 0;
 110 }
 111
 112 static int
 113 read_dev_supers(char *filename, struct btrfs_recover_superblock *recover)
 114 {
 115         int i, ret, fd;
 116         u8 buf[BTRFS_SUPER_INFO_SIZE];
 117         u64 max_gen, bytenr;
 118         struct btrfs_super_block *sb = (struct btrfs_super_block *)buf;
 119
 120         /* just ignore errno that were set in btrfs_scan_fs_devices() */
 121         errno = 0;
 122
 123         fd = open(filename, O_RDONLY);
 124         if (fd < 0)
 125                 return -errno;
 126
 127         for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
 128                 bytenr = btrfs_sb_offset(i);
 129
 130                 ret = btrfs_read_dev_super(fd, sb, bytenr, SBREAD_DEFAULT);
 131                 if (!ret) {
 132                         ret = add_superblock_record(sb, filename, bytenr,
 133                                                         &recover->good_supers);
 134                         if (ret)
 135                                 goto out;
 136                         max_gen = btrfs_super_generation(sb);
 137                         if (max_gen > recover->max_generation)
 138                                 recover->max_generation = max_gen;
 139                 } else if (ret != -ENOENT){
 140                         /*
 141                          * Skip superblock which doesn't exist, only adds
 142                          * really corrupted superblock
 143                          */
 144                         ret = add_superblock_record(sb, filename, bytenr,
 145                                                 &recover->bad_supers);
 146                         if (ret)
 147                                 goto out;
 148                 }
 149         }
 150         ret = 0;
 151 out:
 152         close(fd);
 153         return ret;
 154 }
 155
 156 static int read_fs_supers(struct btrfs_recover_superblock *recover)
 157 {
 158         struct super_block_record *record;
 159         struct super_block_record *next_record;
 160         struct btrfs_device *dev;
 161         int ret;
 162         u64 gen;
 163
 164         list_for_each_entry(dev, &recover->fs_devices->devices,
 165                                 dev_list) {
 166                 ret = read_dev_supers(dev->name, recover);
 167                 if (ret)
 168                         return ret;
 169         }
 170         list_for_each_entry_safe(record, next_record,
 171                         &recover->good_supers, list) {
 172                 gen = btrfs_super_generation(&record->sb);
 173                 if (gen < recover->max_generation)
 174                         list_move_tail(&record->list, &recover->bad_supers);
 175         }
 176
 177         return 0;
 178 }
 179
 180 static void print_super_info(struct super_block_record *record)
 181 {
 182         printf("\t\tdevice name = %s\n", record->device_name);
 183         printf("\t\tsuperblock bytenr = %llu\n", record->bytenr);
 184 }
 185
 186 static void print_all_supers(struct btrfs_recover_superblock *recover)
 187 {
 188         struct super_block_record *record;
 189
 190         printf("\t[All good supers]:\n");
 191         list_for_each_entry(record, &recover->good_supers, list) {
 192                 print_super_info(record);
 193                 printf("\n");
 194         }
 195
 196         printf("\t[All bad supers]:\n");
 197         list_for_each_entry(record, &recover->bad_supers, list) {
 198                 print_super_info(record);
 199                 printf("\n");
 200         }
 201         printf("\n");
 202 }
 203
 204 static void recover_err_str(int ret)
 205 {
 206         switch (ret) {
 207         case 0:
 208                 printf("All supers are valid, no need to recover\n");
 209                 break;
 210         case 1:
 211                 printf("Usage or syntax errors\n");
 212                 break;
 213         case 2:
 214                 printf("Recovered bad superblocks successful\n");
 215                 break;
 216         case 3:
 217                 printf("Failed to recover bad superblocks\n");
 218                 break;
 219         case 4:
 220                 printf("Aborted to recover bad superblocks\n");
 221                 break;
 222         default:
 223                 printf("Unknown recover result\n");
 224                 break;
 225         }
 226 }
 227
 228 int btrfs_recover_superblocks(const char *dname,
 229                         int verbose, int yes)
 230 {
 231         int fd, ret;
 232         struct btrfs_recover_superblock recover;
 233         struct super_block_record *record;
 234         struct btrfs_root *root = NULL;
 235
 236         fd = open(dname, O_RDONLY);
 237         if (fd < 0) {
 238                 fprintf(stderr, "open %s error\n", dname);
 239                 return 1;
 240         }
 241         init_recover_superblock(&recover);
 242
 243         ret = btrfs_scan_fs_devices(fd, dname, &recover.fs_devices, 0,
 244                         SBREAD_RECOVER, 0);
 245         close(fd);
 246         if (ret) {
 247                 ret = 1;
 248                 goto no_recover;
 249         }
 250
 251         if (verbose)
 252                 print_all_devices(&recover.fs_devices->devices);
 253
 254         ret = read_fs_supers(&recover);
 255         if (ret) {
 256                 ret = 1;
 257                 goto no_recover;
 258         }
 259         if (verbose) {
 260                 printf("Before Recovering:\n");
 261                 print_all_supers(&recover);
 262         }
 263
 264         if (list_empty(&recover.bad_supers))
 265                 goto no_recover;
 266
 267         if (!yes) {
 268                 ret = ask_user("Make sure this is a btrfs disk otherwise the tool will destroy other fs, Are you sure?");
 269                 if (!ret) {
 270                         ret = 4;
 271                         goto no_recover;
 272                 }
 273         }
 274         record = list_first_entry(&recover.good_supers,
 275                                   struct super_block_record, list);
 276
 277         root = open_ctree(record->device_name, record->bytenr,
 278                           OPEN_CTREE_RECOVER_SUPER | OPEN_CTREE_WRITES);
 279         if (!root) {
 280                 ret = 3;
 281                 goto no_recover;
 282         }
 283         /* reset super_bytenr in order that we will rewrite all supers */
 284         root->fs_info->super_bytenr = BTRFS_SUPER_INFO_OFFSET;
 285         ret = write_all_supers(root->fs_info);
 286         if (!ret)
 287                 ret = 2;
 288         else
 289                 ret = 3;
 290
 291         close_ctree(root);
 292 no_recover:
 293         recover_err_str(ret);
 294         free_recover_superblock(&recover);
 295         /* check if we have freed fs_devices in close_ctree() */
 296         if (!root)
 297                 btrfs_close_devices(recover.fs_devices);
 298         return ret;
 299 }
 300