fs/bcachefs/recovery.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #include "bcachefs.h"
   4 #include "alloc_background.h"
   5 #include "btree_gc.h"
   6 #include "btree_update.h"
   7 #include "btree_update_interior.h"
   8 #include "btree_io.h"
   9 #include "buckets.h"
  10 #include "dirent.h"
  11 #include "ec.h"
  12 #include "error.h"
  13 #include "fsck.h"
  14 #include "journal_io.h"
  15 #include "quota.h"
  16 #include "recovery.h"
  17 #include "replicas.h"
  18 #include "super-io.h"
  19
  20 #include <linux/stat.h>
  21
  22 #define QSTR(n) { { { .len = strlen(n) } }, .name = n }
  23
  24 static struct bkey_i *btree_root_find(struct bch_fs *c,
  25                                       struct bch_sb_field_clean *clean,
  26                                       struct jset *j,
  27                                       enum btree_id id, unsigned *level)
  28 {
  29         struct bkey_i *k;
  30         struct jset_entry *entry, *start, *end;
  31
  32         if (clean) {
  33                 start = clean->start;
  34                 end = vstruct_end(&clean->field);
  35         } else {
  36                 start = j->start;
  37                 end = vstruct_last(j);
  38         }
  39
  40         for (entry = start; entry < end; entry = vstruct_next(entry))
  41                 if (entry->type == BCH_JSET_ENTRY_btree_root &&
  42                     entry->btree_id == id)
  43                         goto found;
  44
  45         return NULL;
  46 found:
  47         if (!entry->u64s)
  48                 return ERR_PTR(-EINVAL);
  49
  50         k = entry->start;
  51         *level = entry->level;
  52         return k;
  53 }
  54
  55 static int journal_replay_entry_early(struct bch_fs *c,
  56                                       struct jset_entry *entry)
  57 {
  58         int ret = 0;
  59
  60         switch (entry->type) {
  61         case BCH_JSET_ENTRY_btree_root: {
  62                 struct btree_root *r = &c->btree_roots[entry->btree_id];
  63
  64                 if (entry->u64s) {
  65                         r->level = entry->level;
  66                         bkey_copy(&r->key, &entry->start[0]);
  67                         r->error = 0;
  68                 } else {
  69                         r->error = -EIO;
  70                 }
  71                 r->alive = true;
  72                 break;
  73         }
  74         case BCH_JSET_ENTRY_usage: {
  75                 struct jset_entry_usage *u =
  76                         container_of(entry, struct jset_entry_usage, entry);
  77
  78                 switch (entry->btree_id) {
  79                 case FS_USAGE_RESERVED:
  80                         if (entry->level < BCH_REPLICAS_MAX)
  81                                 percpu_u64_set(&c->usage[0]->
  82                                                persistent_reserved[entry->level],
  83                                                le64_to_cpu(u->v));
  84                         break;
  85                 case FS_USAGE_INODES:
  86                         percpu_u64_set(&c->usage[0]->nr_inodes,
  87                                        le64_to_cpu(u->v));
  88                         break;
  89                 case FS_USAGE_KEY_VERSION:
  90                         atomic64_set(&c->key_version,
  91                                      le64_to_cpu(u->v));
  92                         break;
  93                 }
  94
  95                 break;
  96         }
  97         case BCH_JSET_ENTRY_data_usage: {
  98                 struct jset_entry_data_usage *u =
  99                         container_of(entry, struct jset_entry_data_usage, entry);
 100                 ret = bch2_replicas_set_usage(c, &u->r,
 101                                               le64_to_cpu(u->v));
 102                 break;
 103         }
 104         }
 105
 106         return ret;
 107 }
 108
 109 static int verify_superblock_clean(struct bch_fs *c,
 110                                    struct bch_sb_field_clean *clean,
 111                                    struct jset *j)
 112 {
 113         unsigned i;
 114         int ret = 0;
 115
 116         if (!clean || !j)
 117                 return 0;
 118
 119         if (mustfix_fsck_err_on(j->seq != clean->journal_seq, c,
 120                         "superblock journal seq (%llu) doesn't match journal (%llu) after clean shutdown",
 121                         le64_to_cpu(clean->journal_seq),
 122                         le64_to_cpu(j->seq)))
 123                 bch2_fs_mark_clean(c, false);
 124
 125         mustfix_fsck_err_on(j->read_clock != clean->read_clock, c,
 126                         "superblock read clock doesn't match journal after clean shutdown");
 127         mustfix_fsck_err_on(j->write_clock != clean->write_clock, c,
 128                         "superblock read clock doesn't match journal after clean shutdown");
 129
 130         for (i = 0; i < BTREE_ID_NR; i++) {
 131                 struct bkey_i *k1, *k2;
 132                 unsigned l1 = 0, l2 = 0;
 133
 134                 k1 = btree_root_find(c, clean, NULL, i, &l1);
 135                 k2 = btree_root_find(c, NULL, j, i, &l2);
 136
 137                 if (!k1 && !k2)
 138                         continue;
 139
 140                 mustfix_fsck_err_on(!k1 || !k2 ||
 141                                     IS_ERR(k1) ||
 142                                     IS_ERR(k2) ||
 143                                     k1->k.u64s != k2->k.u64s ||
 144                                     memcmp(k1, k2, bkey_bytes(k1)) ||
 145                                     l1 != l2, c,
 146                         "superblock btree root doesn't match journal after clean shutdown");
 147         }
 148 fsck_err:
 149         return ret;
 150 }
 151
 152 static bool journal_empty(struct list_head *journal)
 153 {
 154         struct journal_replay *i;
 155         struct jset_entry *entry;
 156
 157         if (list_empty(journal))
 158                 return true;
 159
 160         i = list_last_entry(journal, struct journal_replay, list);
 161
 162         if (i->j.last_seq != i->j.seq)
 163                 return false;
 164
 165         list_for_each_entry(i, journal, list) {
 166                 vstruct_for_each(&i->j, entry) {
 167                         if (entry->type == BCH_JSET_ENTRY_btree_root ||
 168                             entry->type == BCH_JSET_ENTRY_usage ||
 169                             entry->type == BCH_JSET_ENTRY_data_usage)
 170                                 continue;
 171
 172                         if (entry->type == BCH_JSET_ENTRY_btree_keys &&
 173                             !entry->u64s)
 174                                 continue;
 175                         return false;
 176                 }
 177         }
 178
 179         return true;
 180 }
 181
 182 int bch2_fs_recovery(struct bch_fs *c)
 183 {
 184         const char *err = "cannot allocate memory";
 185         struct bch_sb_field_clean *clean = NULL, *sb_clean = NULL;
 186         struct jset_entry *entry;
 187         LIST_HEAD(journal);
 188         struct jset *j = NULL;
 189         unsigned i;
 190         bool run_gc = c->opts.fsck ||
 191                 !(c->sb.compat & (1ULL << BCH_COMPAT_FEAT_ALLOC_INFO));
 192         int ret;
 193
 194         mutex_lock(&c->sb_lock);
 195         if (!c->replicas.entries) {
 196                 bch_info(c, "building replicas info");
 197                 set_bit(BCH_FS_REBUILD_REPLICAS, &c->flags);
 198         }
 199
 200         if (c->sb.clean)
 201                 sb_clean = bch2_sb_get_clean(c->disk_sb.sb);
 202         if (sb_clean) {
 203                 clean = kmemdup(sb_clean, vstruct_bytes(&sb_clean->field),
 204                                 GFP_KERNEL);
 205                 if (!clean) {
 206                         ret = -ENOMEM;
 207                         mutex_unlock(&c->sb_lock);
 208                         goto err;
 209                 }
 210
 211                 if (le16_to_cpu(c->disk_sb.sb->version) <
 212                     bcachefs_metadata_version_bkey_renumber)
 213                         bch2_sb_clean_renumber(clean, READ);
 214         }
 215         mutex_unlock(&c->sb_lock);
 216
 217         if (clean)
 218                 bch_info(c, "recovering from clean shutdown, journal seq %llu",
 219                          le64_to_cpu(clean->journal_seq));
 220
 221         if (!clean || c->opts.fsck) {
 222                 ret = bch2_journal_read(c, &journal);
 223                 if (ret)
 224                         goto err;
 225
 226                 j = &list_entry(journal.prev, struct journal_replay, list)->j;
 227         } else {
 228                 ret = bch2_journal_set_seq(c,
 229                                            le64_to_cpu(clean->journal_seq),
 230                                            le64_to_cpu(clean->journal_seq));
 231                 BUG_ON(ret);
 232         }
 233
 234         ret = verify_superblock_clean(c, clean, j);
 235         if (ret)
 236                 goto err;
 237
 238         fsck_err_on(clean && !journal_empty(&journal), c,
 239                     "filesystem marked clean but journal not empty");
 240
 241         err = "insufficient memory";
 242         if (clean) {
 243                 c->bucket_clock[READ].hand = le16_to_cpu(clean->read_clock);
 244                 c->bucket_clock[WRITE].hand = le16_to_cpu(clean->write_clock);
 245
 246                 for (entry = clean->start;
 247                      entry != vstruct_end(&clean->field);
 248                      entry = vstruct_next(entry)) {
 249                         ret = journal_replay_entry_early(c, entry);
 250                         if (ret)
 251                                 goto err;
 252                 }
 253         } else {
 254                 struct journal_replay *i;
 255
 256                 c->bucket_clock[READ].hand = le16_to_cpu(j->read_clock);
 257                 c->bucket_clock[WRITE].hand = le16_to_cpu(j->write_clock);
 258
 259                 list_for_each_entry(i, &journal, list)
 260                         vstruct_for_each(&i->j, entry) {
 261                                 ret = journal_replay_entry_early(c, entry);
 262                                 if (ret)
 263                                         goto err;
 264                         }
 265         }
 266
 267         bch2_fs_usage_initialize(c);
 268
 269         for (i = 0; i < BTREE_ID_NR; i++) {
 270                 struct btree_root *r = &c->btree_roots[i];
 271
 272                 if (!r->alive)
 273                         continue;
 274
 275                 err = "invalid btree root pointer";
 276                 ret = -1;
 277                 if (r->error)
 278                         goto err;
 279
 280                 if (i == BTREE_ID_ALLOC &&
 281                     test_reconstruct_alloc(c))
 282                         continue;
 283
 284                 err = "error reading btree root";
 285                 ret = bch2_btree_root_read(c, i, &r->key, r->level);
 286                 if (ret) {
 287                         if (i != BTREE_ID_ALLOC)
 288                                 goto err;
 289
 290                         mustfix_fsck_err(c, "error reading btree root");
 291                         run_gc = true;
 292                 }
 293         }
 294
 295         for (i = 0; i < BTREE_ID_NR; i++)
 296                 if (!c->btree_roots[i].b)
 297                         bch2_btree_root_alloc(c, i);
 298
 299         err = "error reading allocation information";
 300         ret = bch2_alloc_read(c, &journal);
 301         if (ret)
 302                 goto err;
 303
 304         bch_verbose(c, "starting stripes_read");
 305         ret = bch2_stripes_read(c, &journal);
 306         if (ret)
 307                 goto err;
 308         bch_verbose(c, "stripes_read done");
 309
 310         set_bit(BCH_FS_ALLOC_READ_DONE, &c->flags);
 311
 312         if (run_gc) {
 313                 bch_verbose(c, "starting mark and sweep:");
 314                 err = "error in recovery";
 315                 ret = bch2_gc(c, &journal, true);
 316                 if (ret)
 317                         goto err;
 318                 bch_verbose(c, "mark and sweep done");
 319         }
 320
 321         clear_bit(BCH_FS_REBUILD_REPLICAS, &c->flags);
 322         set_bit(BCH_FS_INITIAL_GC_DONE, &c->flags);
 323
 324         /*
 325          * Skip past versions that might have possibly been used (as nonces),
 326          * but hadn't had their pointers written:
 327          */
 328         if (c->sb.encryption_type && !c->sb.clean)
 329                 atomic64_add(1 << 16, &c->key_version);
 330
 331         if (c->opts.noreplay)
 332                 goto out;
 333
 334         /*
 335          * Mark dirty before journal replay, fsck:
 336          * XXX: after a clean shutdown, this could be done lazily only when fsck
 337          * finds an error
 338          */
 339         bch2_fs_mark_clean(c, false);
 340
 341         /*
 342          * bch2_fs_journal_start() can't happen sooner, or btree_gc_finish()
 343          * will give spurious errors about oldest_gen > bucket_gen -
 344          * this is a hack but oh well.
 345          */
 346         bch2_fs_journal_start(&c->journal);
 347
 348         err = "error starting allocator";
 349         ret = bch2_fs_allocator_start(c);
 350         if (ret)
 351                 goto err;
 352
 353         bch_verbose(c, "starting journal replay:");
 354         err = "journal replay failed";
 355         ret = bch2_journal_replay(c, &journal);
 356         if (ret)
 357                 goto err;
 358         bch_verbose(c, "journal replay done");
 359
 360         if (c->opts.norecovery)
 361                 goto out;
 362
 363         err = "error in fsck";
 364         ret = bch2_fsck(c);
 365         if (ret)
 366                 goto err;
 367
 368         mutex_lock(&c->sb_lock);
 369         if (c->opts.version_upgrade) {
 370                 if (c->sb.version < bcachefs_metadata_version_new_versioning)
 371                         c->disk_sb.sb->version_min =
 372                                 le16_to_cpu(bcachefs_metadata_version_min);
 373                 c->disk_sb.sb->version = le16_to_cpu(bcachefs_metadata_version_current);
 374         }
 375
 376         if (!test_bit(BCH_FS_FSCK_UNFIXED_ERRORS, &c->flags))
 377                 c->disk_sb.sb->features[0] |= 1ULL << BCH_FEATURE_ATOMIC_NLINK;
 378         mutex_unlock(&c->sb_lock);
 379
 380         if (enabled_qtypes(c)) {
 381                 bch_verbose(c, "reading quotas:");
 382                 ret = bch2_fs_quota_read(c);
 383                 if (ret)
 384                         goto err;
 385                 bch_verbose(c, "quotas done");
 386         }
 387
 388 out:
 389         bch2_journal_entries_free(&journal);
 390         kfree(clean);
 391         return ret;
 392 err:
 393 fsck_err:
 394         pr_err("Error in recovery: %s (%i)", err, ret);
 395         goto out;
 396 }
 397
 398 int bch2_fs_initialize(struct bch_fs *c)
 399 {
 400         struct bch_inode_unpacked root_inode, lostfound_inode;
 401         struct bkey_inode_buf packed_inode;
 402         struct bch_hash_info root_hash_info;
 403         struct qstr lostfound = QSTR("lost+found");
 404         const char *err = "cannot allocate memory";
 405         struct bch_dev *ca;
 406         LIST_HEAD(journal);
 407         unsigned i;
 408         int ret;
 409
 410         bch_notice(c, "initializing new filesystem");
 411
 412         mutex_lock(&c->sb_lock);
 413         for_each_online_member(ca, c, i)
 414                 bch2_mark_dev_superblock(c, ca, 0);
 415         mutex_unlock(&c->sb_lock);
 416
 417         set_bit(BCH_FS_ALLOC_READ_DONE, &c->flags);
 418         set_bit(BCH_FS_INITIAL_GC_DONE, &c->flags);
 419
 420         for (i = 0; i < BTREE_ID_NR; i++)
 421                 bch2_btree_root_alloc(c, i);
 422
 423         err = "unable to allocate journal buckets";
 424         for_each_online_member(ca, c, i) {
 425                 ret = bch2_dev_journal_alloc(ca);
 426                 if (ret) {
 427                         percpu_ref_put(&ca->io_ref);
 428                         goto err;
 429                 }
 430         }
 431
 432         /*
 433          * journal_res_get() will crash if called before this has
 434          * set up the journal.pin FIFO and journal.cur pointer:
 435          */
 436         bch2_fs_journal_start(&c->journal);
 437         bch2_journal_set_replay_done(&c->journal);
 438
 439         err = "error starting allocator";
 440         ret = bch2_fs_allocator_start(c);
 441         if (ret)
 442                 goto err;
 443
 444         bch2_inode_init(c, &root_inode, 0, 0,
 445                         S_IFDIR|S_IRWXU|S_IRUGO|S_IXUGO, 0, NULL);
 446         root_inode.bi_inum = BCACHEFS_ROOT_INO;
 447         root_inode.bi_nlink++; /* lost+found */
 448         bch2_inode_pack(&packed_inode, &root_inode);
 449
 450         err = "error creating root directory";
 451         ret = bch2_btree_insert(c, BTREE_ID_INODES,
 452                                 &packed_inode.inode.k_i,
 453                                 NULL, NULL, 0);
 454         if (ret)
 455                 goto err;
 456
 457         bch2_inode_init(c, &lostfound_inode, 0, 0,
 458                         S_IFDIR|S_IRWXU|S_IRUGO|S_IXUGO, 0,
 459                         &root_inode);
 460         lostfound_inode.bi_inum = BCACHEFS_ROOT_INO + 1;
 461         bch2_inode_pack(&packed_inode, &lostfound_inode);
 462
 463         err = "error creating lost+found";
 464         ret = bch2_btree_insert(c, BTREE_ID_INODES,
 465                                 &packed_inode.inode.k_i,
 466                                 NULL, NULL, 0);
 467         if (ret)
 468                 goto err;
 469
 470         root_hash_info = bch2_hash_info_init(c, &root_inode);
 471
 472         ret = bch2_dirent_create(c, BCACHEFS_ROOT_INO, &root_hash_info, DT_DIR,
 473                                  &lostfound, lostfound_inode.bi_inum, NULL,
 474                                  BTREE_INSERT_NOFAIL);
 475         if (ret)
 476                 goto err;
 477
 478         if (enabled_qtypes(c)) {
 479                 ret = bch2_fs_quota_read(c);
 480                 if (ret)
 481                         goto err;
 482         }
 483
 484         err = "error writing first journal entry";
 485         ret = bch2_journal_meta(&c->journal);
 486         if (ret)
 487                 goto err;
 488
 489         mutex_lock(&c->sb_lock);
 490         c->disk_sb.sb->version = c->disk_sb.sb->version_min =
 491                 le16_to_cpu(bcachefs_metadata_version_current);
 492         c->disk_sb.sb->features[0] |= 1ULL << BCH_FEATURE_ATOMIC_NLINK;
 493
 494         SET_BCH_SB_INITIALIZED(c->disk_sb.sb, true);
 495         SET_BCH_SB_CLEAN(c->disk_sb.sb, false);
 496
 497         bch2_write_super(c);
 498         mutex_unlock(&c->sb_lock);
 499
 500         return 0;
 501 err:
 502         pr_err("Error initializing new filesystem: %s (%i)", err, ret);
 503         return ret;
 504 }