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 == -EIO){
 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 struct super_block_record *recover_get_good_super(
 181                                 struct btrfs_recover_superblock *recover)
 182 {
 183         struct super_block_record *record;
 184         record = list_entry(recover->good_supers.next,
 185                                 struct super_block_record, list);
 186         return record;
 187 }
 188
 189 static void print_all_devices(struct list_head *devices)
 190 {
 191         struct btrfs_device *dev;
 192
 193         printf("All Devices:\n");
 194         list_for_each_entry(dev, devices, dev_list) {
 195                 printf("\t");
 196                 printf("Device: id = %llu, name = %s\n",
 197                         dev->devid, dev->name);
 198         }
 199         printf("\n");
 200 }
 201
 202 static void print_super_info(struct super_block_record *record)
 203 {
 204         printf("\t\tdevice name = %s\n", record->device_name);
 205         printf("\t\tsuperblock bytenr = %llu\n", record->bytenr);
 206 }
 207
 208 static void print_all_supers(struct btrfs_recover_superblock *recover)
 209 {
 210         struct super_block_record *record;
 211
 212         printf("\t[All good supers]:\n");
 213         list_for_each_entry(record, &recover->good_supers, list) {
 214                 print_super_info(record);
 215                 printf("\n");
 216         }
 217
 218         printf("\t[All bad supers]:\n");
 219         list_for_each_entry(record, &recover->bad_supers, list) {
 220                 print_super_info(record);
 221                 printf("\n");
 222         }
 223         printf("\n");
 224 }
 225
 226 static void recover_err_str(int ret)
 227 {
 228         switch (ret) {
 229         case 0:
 230                 printf("All supers are valid, no need to recover\n");
 231                 break;
 232         case 1:
 233                 printf("Usage or syntax errors\n");
 234                 break;
 235         case 2:
 236                 printf("Recovered bad superblocks successful\n");
 237                 break;
 238         case 3:
 239                 printf("Failed to recover bad superblocks\n");
 240                 break;
 241         case 4:
 242                 printf("Aborted to recover bad superblocks\n");
 243                 break;
 244         default:
 245                 printf("Unknown recover result\n");
 246                 break;
 247         }
 248 }
 249
 250 int btrfs_recover_superblocks(const char *dname,
 251                         int verbose, int yes)
 252 {
 253         int fd, ret;
 254         struct btrfs_recover_superblock recover;
 255         struct super_block_record *record;
 256         struct btrfs_root *root = NULL;
 257
 258         fd = open(dname, O_RDONLY);
 259         if (fd < 0) {
 260                 fprintf(stderr, "open %s error\n", dname);
 261                 return 1;
 262         }
 263         init_recover_superblock(&recover);
 264
 265         ret = btrfs_scan_fs_devices(fd, dname, &recover.fs_devices, 0,
 266                         SBREAD_RECOVER, 0);
 267         close(fd);
 268         if (ret) {
 269                 ret = 1;
 270                 goto no_recover;
 271         }
 272
 273         if (verbose)
 274                 print_all_devices(&recover.fs_devices->devices);
 275
 276         ret = read_fs_supers(&recover);
 277         if (ret) {
 278                 ret = 1;
 279                 goto no_recover;
 280         }
 281         if (verbose) {
 282                 printf("Before Recovering:\n");
 283                 print_all_supers(&recover);
 284         }
 285
 286         if (list_empty(&recover.bad_supers))
 287                 goto no_recover;
 288
 289         if (!yes) {
 290                 ret = ask_user("Make sure this is a btrfs disk otherwise the tool will destroy other fs, Are you sure?");
 291                 if (!ret) {
 292                         ret = 4;
 293                         goto no_recover;
 294                 }
 295         }
 296         record = recover_get_good_super(&recover);
 297         root = open_ctree(record->device_name, record->bytenr,
 298                           OPEN_CTREE_RECOVER_SUPER | OPEN_CTREE_WRITES);
 299         if (!root) {
 300                 ret = 3;
 301                 goto no_recover;
 302         }
 303         /* reset super_bytenr in order that we will rewrite all supers */
 304         root->fs_info->super_bytenr = BTRFS_SUPER_INFO_OFFSET;
 305         ret = write_all_supers(root->fs_info);
 306         if (!ret)
 307                 ret = 2;
 308         else
 309                 ret = 3;
 310
 311         close_ctree(root);
 312 no_recover:
 313         recover_err_str(ret);
 314         free_recover_superblock(&recover);
 315         /* check if we have freed fs_devices in close_ctree() */
 316         if (!root)
 317                 btrfs_close_devices(recover.fs_devices);
 318         return ret;
 319 }
 320