git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs/subvolume.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #include "bcachefs.h"
   4 #include "btree_key_cache.h"
   5 #include "btree_update.h"
   6 #include "error.h"
   7 #include "fs.h"
   8 #include "subvolume.h"
   9
  10 /* Snapshot tree: */
  11
  12 static void bch2_delete_dead_snapshots_work(struct work_struct *);
  13 static void bch2_delete_dead_snapshots(struct bch_fs *);
  14
  15 void bch2_snapshot_to_text(struct printbuf *out, struct bch_fs *c,
  16                            struct bkey_s_c k)
  17 {
  18         struct bkey_s_c_snapshot s = bkey_s_c_to_snapshot(k);
  19
  20         pr_buf(out, "is_subvol %llu deleted %llu parent %u children %u %u subvol %u",
  21                BCH_SNAPSHOT_SUBVOL(s.v),
  22                BCH_SNAPSHOT_DELETED(s.v),
  23                le32_to_cpu(s.v->parent),
  24                le32_to_cpu(s.v->children[0]),
  25                le32_to_cpu(s.v->children[1]),
  26                le32_to_cpu(s.v->subvol));
  27 }
  28
  29 const char *bch2_snapshot_invalid(const struct bch_fs *c, struct bkey_s_c k)
  30 {
  31         struct bkey_s_c_snapshot s;
  32         u32 i, id;
  33
  34         if (bkey_cmp(k.k->p, POS(0, U32_MAX)) > 0 ||
  35             bkey_cmp(k.k->p, POS(0, 1)) < 0)
  36                 return "bad pos";
  37
  38         if (bkey_val_bytes(k.k) != sizeof(struct bch_snapshot))
  39                 return "bad val size";
  40
  41         s = bkey_s_c_to_snapshot(k);
  42
  43         id = le32_to_cpu(s.v->parent);
  44         if (id && id <= k.k->p.offset)
  45                 return "bad parent node";
  46
  47         if (le32_to_cpu(s.v->children[0]) < le32_to_cpu(s.v->children[1]))
  48                 return "children not normalized";
  49
  50         if (s.v->children[0] &&
  51             s.v->children[0] == s.v->children[1])
  52                 return "duplicate child nodes";
  53
  54         for (i = 0; i < 2; i++) {
  55                 id = le32_to_cpu(s.v->children[i]);
  56
  57                 if (id >= k.k->p.offset)
  58                         return "bad child node";
  59         }
  60
  61         return NULL;
  62 }
  63
  64 int bch2_mark_snapshot(struct btree_trans *trans,
  65                        struct bkey_s_c old, struct bkey_s_c new,
  66                        unsigned flags)
  67 {
  68         struct bch_fs *c = trans->c;
  69         struct snapshot_t *t;
  70
  71         t = genradix_ptr_alloc(&c->snapshots,
  72                                U32_MAX - new.k->p.offset,
  73                                GFP_KERNEL);
  74         if (!t)
  75                 return -ENOMEM;
  76
  77         if (new.k->type == KEY_TYPE_snapshot) {
  78                 struct bkey_s_c_snapshot s = bkey_s_c_to_snapshot(new);
  79
  80                 t->parent       = le32_to_cpu(s.v->parent);
  81                 t->children[0]  = le32_to_cpu(s.v->children[0]);
  82                 t->children[1]  = le32_to_cpu(s.v->children[1]);
  83                 t->subvol       = BCH_SNAPSHOT_SUBVOL(s.v) ? le32_to_cpu(s.v->subvol) : 0;
  84         } else {
  85                 t->parent       = 0;
  86                 t->children[0]  = 0;
  87                 t->children[1]  = 0;
  88                 t->subvol       = 0;
  89         }
  90
  91         return 0;
  92 }
  93
  94 static int snapshot_lookup(struct btree_trans *trans, u32 id,
  95                            struct bch_snapshot *s)
  96 {
  97         struct btree_iter iter;
  98         struct bkey_s_c k;
  99         int ret;
 100
 101         bch2_trans_iter_init(trans, &iter, BTREE_ID_snapshots, POS(0, id),
 102                              BTREE_ITER_WITH_UPDATES);
 103         k = bch2_btree_iter_peek_slot(&iter);
 104         ret = bkey_err(k) ?: k.k->type == KEY_TYPE_snapshot ? 0 : -ENOENT;
 105
 106         if (!ret)
 107                 *s = *bkey_s_c_to_snapshot(k).v;
 108
 109         bch2_trans_iter_exit(trans, &iter);
 110         return ret;
 111 }
 112
 113 static int snapshot_live(struct btree_trans *trans, u32 id)
 114 {
 115         struct bch_snapshot v;
 116         int ret;
 117
 118         if (!id)
 119                 return 0;
 120
 121         ret = lockrestart_do(trans, snapshot_lookup(trans, id, &v));
 122         if (ret == -ENOENT)
 123                 bch_err(trans->c, "snapshot node %u not found", id);
 124         if (ret)
 125                 return ret;
 126
 127         return !BCH_SNAPSHOT_DELETED(&v);
 128 }
 129
 130 static int bch2_snapshots_set_equiv(struct btree_trans *trans)
 131 {
 132         struct bch_fs *c = trans->c;
 133         struct btree_iter iter;
 134         struct bkey_s_c k;
 135         struct bkey_s_c_snapshot snap;
 136         unsigned i;
 137         int ret;
 138
 139         for_each_btree_key(trans, iter, BTREE_ID_snapshots,
 140                            POS_MIN, 0, k, ret) {
 141                 u32 id = k.k->p.offset, child[2];
 142                 unsigned nr_live = 0, live_idx;
 143
 144                 if (k.k->type != KEY_TYPE_snapshot)
 145                         continue;
 146
 147                 snap = bkey_s_c_to_snapshot(k);
 148                 child[0] = le32_to_cpu(snap.v->children[0]);
 149                 child[1] = le32_to_cpu(snap.v->children[1]);
 150
 151                 for (i = 0; i < 2; i++) {
 152                         ret = snapshot_live(trans, child[i]);
 153                         if (ret < 0)
 154                                 break;
 155
 156                         if (ret)
 157                                 live_idx = i;
 158                         nr_live += ret;
 159                 }
 160
 161                 snapshot_t(c, id)->equiv = nr_live == 1
 162                         ? snapshot_t(c, child[live_idx])->equiv
 163                         : id;
 164         }
 165         bch2_trans_iter_exit(trans, &iter);
 166
 167         if (ret)
 168                 bch_err(c, "error walking snapshots: %i", ret);
 169
 170         return ret;
 171 }
 172
 173 /* fsck: */
 174 static int bch2_snapshot_check(struct btree_trans *trans,
 175                                struct bkey_s_c_snapshot s)
 176 {
 177         struct bch_subvolume subvol;
 178         struct bch_snapshot v;
 179         u32 i, id;
 180         int ret;
 181
 182         id = le32_to_cpu(s.v->subvol);
 183         ret = lockrestart_do(trans, bch2_subvolume_get(trans, id, 0, false, &subvol));
 184         if (ret == -ENOENT)
 185                 bch_err(trans->c, "snapshot node %llu has nonexistent subvolume %u",
 186                         s.k->p.offset, id);
 187         if (ret)
 188                 return ret;
 189
 190         if (BCH_SNAPSHOT_SUBVOL(s.v) != (le32_to_cpu(subvol.snapshot) == s.k->p.offset)) {
 191                 bch_err(trans->c, "snapshot node %llu has wrong BCH_SNAPSHOT_SUBVOL",
 192                         s.k->p.offset);
 193                 return -EINVAL;
 194         }
 195
 196         id = le32_to_cpu(s.v->parent);
 197         if (id) {
 198                 ret = lockrestart_do(trans, snapshot_lookup(trans, id, &v));
 199                 if (ret == -ENOENT)
 200                         bch_err(trans->c, "snapshot node %llu has nonexistent parent %u",
 201                                 s.k->p.offset, id);
 202                 if (ret)
 203                         return ret;
 204
 205                 if (le32_to_cpu(v.children[0]) != s.k->p.offset &&
 206                     le32_to_cpu(v.children[1]) != s.k->p.offset) {
 207                         bch_err(trans->c, "snapshot parent %u missing pointer to child %llu",
 208                                 id, s.k->p.offset);
 209                         return -EINVAL;
 210                 }
 211         }
 212
 213         for (i = 0; i < 2 && s.v->children[i]; i++) {
 214                 id = le32_to_cpu(s.v->children[i]);
 215
 216                 ret = lockrestart_do(trans, snapshot_lookup(trans, id, &v));
 217                 if (ret == -ENOENT)
 218                         bch_err(trans->c, "snapshot node %llu has nonexistent child %u",
 219                                 s.k->p.offset, id);
 220                 if (ret)
 221                         return ret;
 222
 223                 if (le32_to_cpu(v.parent) != s.k->p.offset) {
 224                         bch_err(trans->c, "snapshot child %u has wrong parent (got %u should be %llu)",
 225                                 id, le32_to_cpu(v.parent), s.k->p.offset);
 226                         return -EINVAL;
 227                 }
 228         }
 229
 230         return 0;
 231 }
 232
 233 int bch2_fs_snapshots_check(struct bch_fs *c)
 234 {
 235         struct btree_trans trans;
 236         struct btree_iter iter;
 237         struct bkey_s_c k;
 238         struct bch_snapshot s;
 239         unsigned id;
 240         int ret;
 241
 242         bch2_trans_init(&trans, c, 0, 0);
 243
 244         for_each_btree_key(&trans, iter, BTREE_ID_snapshots,
 245                            POS_MIN, 0, k, ret) {
 246                 if (k.k->type != KEY_TYPE_snapshot)
 247                         continue;
 248
 249                 ret = bch2_snapshot_check(&trans, bkey_s_c_to_snapshot(k));
 250                 if (ret)
 251                         break;
 252         }
 253         bch2_trans_iter_exit(&trans, &iter);
 254
 255         if (ret) {
 256                 bch_err(c, "error %i checking snapshots", ret);
 257                 goto err;
 258         }
 259
 260         for_each_btree_key(&trans, iter, BTREE_ID_subvolumes,
 261                            POS_MIN, 0, k, ret) {
 262                 if (k.k->type != KEY_TYPE_subvolume)
 263                         continue;
 264 again_2:
 265                 id = le32_to_cpu(bkey_s_c_to_subvolume(k).v->snapshot);
 266                 ret = snapshot_lookup(&trans, id, &s);
 267
 268                 if (ret == -EINTR) {
 269                         k = bch2_btree_iter_peek(&iter);
 270                         goto again_2;
 271                 } else if (ret == -ENOENT)
 272                         bch_err(c, "subvolume %llu points to nonexistent snapshot %u",
 273                                 k.k->p.offset, id);
 274                 else if (ret)
 275                         break;
 276         }
 277         bch2_trans_iter_exit(&trans, &iter);
 278 err:
 279         bch2_trans_exit(&trans);
 280         return ret;
 281 }
 282
 283 void bch2_fs_snapshots_exit(struct bch_fs *c)
 284 {
 285         genradix_free(&c->snapshots);
 286 }
 287
 288 int bch2_fs_snapshots_start(struct bch_fs *c)
 289 {
 290         struct btree_trans trans;
 291         struct btree_iter iter;
 292         struct bkey_s_c k;
 293         bool have_deleted = false;
 294         int ret = 0;
 295
 296         bch2_trans_init(&trans, c, 0, 0);
 297
 298         for_each_btree_key(&trans, iter, BTREE_ID_snapshots,
 299                            POS_MIN, 0, k, ret) {
 300                if (bkey_cmp(k.k->p, POS(0, U32_MAX)) > 0)
 301                        break;
 302
 303                 if (k.k->type != KEY_TYPE_snapshot) {
 304                         bch_err(c, "found wrong key type %u in snapshot node table",
 305                                 k.k->type);
 306                         continue;
 307                 }
 308
 309                 if (BCH_SNAPSHOT_DELETED(bkey_s_c_to_snapshot(k).v))
 310                         have_deleted = true;
 311
 312                 ret = bch2_mark_snapshot(&trans, bkey_s_c_null, k, 0);
 313                 if (ret)
 314                         break;
 315         }
 316         bch2_trans_iter_exit(&trans, &iter);
 317
 318         if (ret)
 319                 goto err;
 320
 321         ret = bch2_snapshots_set_equiv(&trans);
 322         if (ret)
 323                 goto err;
 324 err:
 325         bch2_trans_exit(&trans);
 326
 327         if (!ret && have_deleted) {
 328                 bch_info(c, "restarting deletion of dead snapshots");
 329                 if (c->opts.fsck) {
 330                         bch2_delete_dead_snapshots_work(&c->snapshot_delete_work);
 331                 } else {
 332                         bch2_delete_dead_snapshots(c);
 333                 }
 334         }
 335
 336         return ret;
 337 }
 338
 339 /*
 340  * Mark a snapshot as deleted, for future cleanup:
 341  */
 342 static int bch2_snapshot_node_set_deleted(struct btree_trans *trans, u32 id)
 343 {
 344         struct btree_iter iter;
 345         struct bkey_s_c k;
 346         struct bkey_i_snapshot *s;
 347         int ret = 0;
 348
 349         bch2_trans_iter_init(trans, &iter, BTREE_ID_snapshots, POS(0, id),
 350                              BTREE_ITER_INTENT);
 351         k = bch2_btree_iter_peek_slot(&iter);
 352         ret = bkey_err(k);
 353         if (ret)
 354                 goto err;
 355
 356         if (k.k->type != KEY_TYPE_snapshot) {
 357                 bch2_fs_inconsistent(trans->c, "missing snapshot %u", id);
 358                 ret = -ENOENT;
 359                 goto err;
 360         }
 361
 362         /* already deleted? */
 363         if (BCH_SNAPSHOT_DELETED(bkey_s_c_to_snapshot(k).v))
 364                 goto err;
 365
 366         s = bch2_trans_kmalloc(trans, sizeof(*s));
 367         ret = PTR_ERR_OR_ZERO(s);
 368         if (ret)
 369                 goto err;
 370
 371         bkey_reassemble(&s->k_i, k);
 372
 373         SET_BCH_SNAPSHOT_DELETED(&s->v, true);
 374         ret = bch2_trans_update(trans, &iter, &s->k_i, 0);
 375         if (ret)
 376                 goto err;
 377 err:
 378         bch2_trans_iter_exit(trans, &iter);
 379         return ret;
 380 }
 381
 382 static int bch2_snapshot_node_delete(struct btree_trans *trans, u32 id)
 383 {
 384         struct btree_iter iter, p_iter = (struct btree_iter) { NULL };
 385         struct bkey_s_c k;
 386         struct bkey_s_c_snapshot s;
 387         struct bkey_i_snapshot *parent;
 388         u32 parent_id;
 389         unsigned i;
 390         int ret = 0;
 391
 392         bch2_trans_iter_init(trans, &iter, BTREE_ID_snapshots, POS(0, id),
 393                              BTREE_ITER_INTENT);
 394         k = bch2_btree_iter_peek_slot(&iter);
 395         ret = bkey_err(k);
 396         if (ret)
 397                 goto err;
 398
 399         if (k.k->type != KEY_TYPE_snapshot) {
 400                 bch2_fs_inconsistent(trans->c, "missing snapshot %u", id);
 401                 ret = -ENOENT;
 402                 goto err;
 403         }
 404
 405         s = bkey_s_c_to_snapshot(k);
 406
 407         BUG_ON(!BCH_SNAPSHOT_DELETED(s.v));
 408         parent_id = le32_to_cpu(s.v->parent);
 409
 410         if (parent_id) {
 411                 bch2_trans_iter_init(trans, &p_iter, BTREE_ID_snapshots,
 412                                      POS(0, parent_id),
 413                                      BTREE_ITER_INTENT);
 414                 k = bch2_btree_iter_peek_slot(&p_iter);
 415                 ret = bkey_err(k);
 416                 if (ret)
 417                         goto err;
 418
 419                 if (k.k->type != KEY_TYPE_snapshot) {
 420                         bch2_fs_inconsistent(trans->c, "missing snapshot %u", parent_id);
 421                         ret = -ENOENT;
 422                         goto err;
 423                 }
 424
 425                 parent = bch2_trans_kmalloc(trans, sizeof(*parent));
 426                 ret = PTR_ERR_OR_ZERO(parent);
 427                 if (ret)
 428                         goto err;
 429
 430                 bkey_reassemble(&parent->k_i, k);
 431
 432                 for (i = 0; i < 2; i++)
 433                         if (le32_to_cpu(parent->v.children[i]) == id)
 434                                 break;
 435
 436                 if (i == 2)
 437                         bch_err(trans->c, "snapshot %u missing child pointer to %u",
 438                                 parent_id, id);
 439                 else
 440                         parent->v.children[i] = 0;
 441
 442                 if (le32_to_cpu(parent->v.children[0]) <
 443                     le32_to_cpu(parent->v.children[1]))
 444                         swap(parent->v.children[0],
 445                              parent->v.children[1]);
 446
 447                 ret = bch2_trans_update(trans, &p_iter, &parent->k_i, 0);
 448                 if (ret)
 449                         goto err;
 450         }
 451
 452         ret = bch2_btree_delete_at(trans, &iter, 0);
 453 err:
 454         bch2_trans_iter_exit(trans, &p_iter);
 455         bch2_trans_iter_exit(trans, &iter);
 456         return ret;
 457 }
 458
 459 static int bch2_snapshot_node_create(struct btree_trans *trans, u32 parent,
 460                                      u32 *new_snapids,
 461                                      u32 *snapshot_subvols,
 462                                      unsigned nr_snapids)
 463 {
 464         struct btree_iter iter;
 465         struct bkey_i_snapshot *n;
 466         struct bkey_s_c k;
 467         unsigned i;
 468         int ret = 0;
 469
 470         bch2_trans_iter_init(trans, &iter, BTREE_ID_snapshots,
 471                              POS_MIN, BTREE_ITER_INTENT);
 472         k = bch2_btree_iter_peek(&iter);
 473         ret = bkey_err(k);
 474         if (ret)
 475                 goto err;
 476
 477         for (i = 0; i < nr_snapids; i++) {
 478                 k = bch2_btree_iter_prev_slot(&iter);
 479                 ret = bkey_err(k);
 480                 if (ret)
 481                         goto err;
 482
 483                 if (!k.k || !k.k->p.offset) {
 484                         ret = -ENOSPC;
 485                         goto err;
 486                 }
 487
 488                 n = bch2_trans_kmalloc(trans, sizeof(*n));
 489                 ret = PTR_ERR_OR_ZERO(n);
 490                 if (ret)
 491                         goto err;
 492
 493                 bkey_snapshot_init(&n->k_i);
 494                 n->k.p          = iter.pos;
 495                 n->v.flags      = 0;
 496                 n->v.parent     = cpu_to_le32(parent);
 497                 n->v.subvol     = cpu_to_le32(snapshot_subvols[i]);
 498                 n->v.pad        = 0;
 499                 SET_BCH_SNAPSHOT_SUBVOL(&n->v, true);
 500
 501                 ret   = bch2_trans_update(trans, &iter, &n->k_i, 0) ?:
 502                         bch2_mark_snapshot(trans, bkey_s_c_null, bkey_i_to_s_c(&n->k_i), 0);
 503                 if (ret)
 504                         goto err;
 505
 506                 new_snapids[i]  = iter.pos.offset;
 507         }
 508
 509         if (parent) {
 510                 bch2_btree_iter_set_pos(&iter, POS(0, parent));
 511                 k = bch2_btree_iter_peek(&iter);
 512                 ret = bkey_err(k);
 513                 if (ret)
 514                         goto err;
 515
 516                 if (k.k->type != KEY_TYPE_snapshot) {
 517                         bch_err(trans->c, "snapshot %u not found", parent);
 518                         ret = -ENOENT;
 519                         goto err;
 520                 }
 521
 522                 n = bch2_trans_kmalloc(trans, sizeof(*n));
 523                 ret = PTR_ERR_OR_ZERO(n);
 524                 if (ret)
 525                         return ret;
 526
 527                 bkey_reassemble(&n->k_i, k);
 528
 529                 if (n->v.children[0] || n->v.children[1]) {
 530                         bch_err(trans->c, "Trying to add child snapshot nodes to parent that already has children");
 531                         ret = -EINVAL;
 532                         goto err;
 533                 }
 534
 535                 n->v.children[0] = cpu_to_le32(new_snapids[0]);
 536                 n->v.children[1] = cpu_to_le32(new_snapids[1]);
 537                 SET_BCH_SNAPSHOT_SUBVOL(&n->v, false);
 538                 ret = bch2_trans_update(trans, &iter, &n->k_i, 0);
 539                 if (ret)
 540                         goto err;
 541         }
 542 err:
 543         bch2_trans_iter_exit(trans, &iter);
 544         return ret;
 545 }
 546
 547 static int snapshot_id_add(struct snapshot_id_list *s, u32 id)
 548 {
 549         BUG_ON(snapshot_list_has_id(s, id));
 550
 551         if (s->nr == s->size) {
 552                 size_t new_size = max(8U, s->size * 2);
 553                 void *n = krealloc(s->d,
 554                                    new_size * sizeof(s->d[0]),
 555                                    GFP_KERNEL);
 556                 if (!n) {
 557                         pr_err("error allocating snapshot ID list");
 558                         return -ENOMEM;
 559                 }
 560
 561                 s->d    = n;
 562                 s->size = new_size;
 563         };
 564
 565         s->d[s->nr++] = id;
 566         return 0;
 567 }
 568
 569 static int bch2_snapshot_delete_keys_btree(struct btree_trans *trans,
 570                                            struct snapshot_id_list *deleted,
 571                                            enum btree_id btree_id)
 572 {
 573         struct bch_fs *c = trans->c;
 574         struct btree_iter iter;
 575         struct bkey_s_c k;
 576         struct snapshot_id_list equiv_seen = { 0 };
 577         struct bpos last_pos = POS_MIN;
 578         int ret = 0;
 579
 580         /*
 581          * XXX: We should also delete whiteouts that no longer overwrite
 582          * anything
 583          */
 584
 585         bch2_trans_iter_init(trans, &iter, btree_id, POS_MIN,
 586                              BTREE_ITER_INTENT|
 587                              BTREE_ITER_PREFETCH|
 588                              BTREE_ITER_NOT_EXTENTS|
 589                              BTREE_ITER_ALL_SNAPSHOTS);
 590
 591         while ((bch2_trans_begin(trans),
 592                 (k = bch2_btree_iter_peek(&iter)).k) &&
 593                !(ret = bkey_err(k))) {
 594                 u32 equiv = snapshot_t(c, k.k->p.snapshot)->equiv;
 595
 596                 if (bkey_cmp(k.k->p, last_pos))
 597                         equiv_seen.nr = 0;
 598                 last_pos = k.k->p;
 599
 600                 if (snapshot_list_has_id(deleted, k.k->p.snapshot) ||
 601                     snapshot_list_has_id(&equiv_seen, equiv)) {
 602                         if (btree_id == BTREE_ID_inodes &&
 603                             bch2_btree_key_cache_flush(trans, btree_id, iter.pos))
 604                                 continue;
 605
 606                         ret = __bch2_trans_do(trans, NULL, NULL,
 607                                               BTREE_INSERT_NOFAIL,
 608                                 bch2_btree_iter_traverse(&iter) ?:
 609                                 bch2_btree_delete_at(trans, &iter,
 610                                         BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE));
 611                         if (ret)
 612                                 break;
 613                 } else {
 614                         ret = snapshot_id_add(&equiv_seen, equiv);
 615                         if (ret)
 616                                 break;
 617                 }
 618
 619                 bch2_btree_iter_advance(&iter);
 620         }
 621         bch2_trans_iter_exit(trans, &iter);
 622
 623         kfree(equiv_seen.d);
 624
 625         return ret;
 626 }
 627
 628 static void bch2_delete_dead_snapshots_work(struct work_struct *work)
 629 {
 630         struct bch_fs *c = container_of(work, struct bch_fs, snapshot_delete_work);
 631         struct btree_trans trans;
 632         struct btree_iter iter;
 633         struct bkey_s_c k;
 634         struct bkey_s_c_snapshot snap;
 635         struct snapshot_id_list deleted = { 0 };
 636         u32 i, id, children[2];
 637         int ret = 0;
 638
 639         bch2_trans_init(&trans, c, 0, 0);
 640
 641         /*
 642          * For every snapshot node: If we have no live children and it's not
 643          * pointed to by a subvolume, delete it:
 644          */
 645         for_each_btree_key(&trans, iter, BTREE_ID_snapshots,
 646                            POS_MIN, 0, k, ret) {
 647                 if (k.k->type != KEY_TYPE_snapshot)
 648                         continue;
 649
 650                 snap = bkey_s_c_to_snapshot(k);
 651                 if (BCH_SNAPSHOT_DELETED(snap.v) ||
 652                     BCH_SNAPSHOT_SUBVOL(snap.v))
 653                         continue;
 654
 655                 children[0] = le32_to_cpu(snap.v->children[0]);
 656                 children[1] = le32_to_cpu(snap.v->children[1]);
 657
 658                 ret   = snapshot_live(&trans, children[0]) ?:
 659                         snapshot_live(&trans, children[1]);
 660                 if (ret < 0)
 661                         break;
 662                 if (ret)
 663                         continue;
 664
 665                 ret = __bch2_trans_do(&trans, NULL, NULL, 0,
 666                         bch2_snapshot_node_set_deleted(&trans, iter.pos.offset));
 667                 if (ret) {
 668                         bch_err(c, "error deleting snapshot %llu: %i", iter.pos.offset, ret);
 669                         break;
 670                 }
 671         }
 672         bch2_trans_iter_exit(&trans, &iter);
 673
 674         if (ret) {
 675                 bch_err(c, "error walking snapshots: %i", ret);
 676                 goto err;
 677         }
 678
 679         ret = bch2_snapshots_set_equiv(&trans);
 680         if (ret)
 681                 goto err;
 682
 683         for_each_btree_key(&trans, iter, BTREE_ID_snapshots,
 684                            POS_MIN, 0, k, ret) {
 685                 if (k.k->type != KEY_TYPE_snapshot)
 686                         continue;
 687
 688                 snap = bkey_s_c_to_snapshot(k);
 689                 if (BCH_SNAPSHOT_DELETED(snap.v)) {
 690                         ret = snapshot_id_add(&deleted, k.k->p.offset);
 691                         if (ret)
 692                                 break;
 693                 }
 694         }
 695         bch2_trans_iter_exit(&trans, &iter);
 696
 697         if (ret) {
 698                 bch_err(c, "error walking snapshots: %i", ret);
 699                 goto err;
 700         }
 701
 702         for (id = 0; id < BTREE_ID_NR; id++) {
 703                 if (!btree_type_has_snapshots(id))
 704                         continue;
 705
 706                 ret = bch2_snapshot_delete_keys_btree(&trans, &deleted, id);
 707                 if (ret) {
 708                         bch_err(c, "error deleting snapshot keys: %i", ret);
 709                         goto err;
 710                 }
 711         }
 712
 713         for (i = 0; i < deleted.nr; i++) {
 714                 ret = __bch2_trans_do(&trans, NULL, NULL, 0,
 715                         bch2_snapshot_node_delete(&trans, deleted.d[i]));
 716                 if (ret) {
 717                         bch_err(c, "error deleting snapshot %u: %i",
 718                                 deleted.d[i], ret);
 719                         goto err;
 720                 }
 721         }
 722 err:
 723         kfree(deleted.d);
 724         bch2_trans_exit(&trans);
 725         percpu_ref_put(&c->writes);
 726 }
 727
 728 static void bch2_delete_dead_snapshots(struct bch_fs *c)
 729 {
 730         if (unlikely(!percpu_ref_tryget(&c->writes)))
 731                 return;
 732
 733         if (!queue_work(system_long_wq, &c->snapshot_delete_work))
 734                 percpu_ref_put(&c->writes);
 735 }
 736
 737 static int bch2_delete_dead_snapshots_hook(struct btree_trans *trans,
 738                                            struct btree_trans_commit_hook *h)
 739 {
 740         bch2_delete_dead_snapshots(trans->c);
 741         return 0;
 742 }
 743
 744 /* Subvolumes: */
 745
 746 const char *bch2_subvolume_invalid(const struct bch_fs *c, struct bkey_s_c k)
 747 {
 748         if (bkey_cmp(k.k->p, SUBVOL_POS_MIN) < 0)
 749                 return "invalid pos";
 750
 751         if (bkey_cmp(k.k->p, SUBVOL_POS_MAX) > 0)
 752                 return "invalid pos";
 753
 754         if (bkey_val_bytes(k.k) != sizeof(struct bch_subvolume))
 755                 return "bad val size";
 756
 757         return NULL;
 758 }
 759
 760 void bch2_subvolume_to_text(struct printbuf *out, struct bch_fs *c,
 761                             struct bkey_s_c k)
 762 {
 763         struct bkey_s_c_subvolume s = bkey_s_c_to_subvolume(k);
 764
 765         pr_buf(out, "root %llu snapshot id %u",
 766                le64_to_cpu(s.v->inode),
 767                le32_to_cpu(s.v->snapshot));
 768 }
 769
 770 int bch2_subvolume_get(struct btree_trans *trans, unsigned subvol,
 771                        bool inconsistent_if_not_found,
 772                        int iter_flags,
 773                        struct bch_subvolume *s)
 774 {
 775         struct btree_iter iter;
 776         struct bkey_s_c k;
 777         int ret;
 778
 779         bch2_trans_iter_init(trans, &iter, BTREE_ID_subvolumes, POS(0, subvol),
 780                              iter_flags);
 781         k = bch2_btree_iter_peek_slot(&iter);
 782         ret = bkey_err(k) ?: k.k->type == KEY_TYPE_subvolume ? 0 : -ENOENT;
 783
 784         if (ret == -ENOENT && inconsistent_if_not_found)
 785                 bch2_fs_inconsistent(trans->c, "missing subvolume %u", subvol);
 786         if (!ret)
 787                 *s = *bkey_s_c_to_subvolume(k).v;
 788
 789         bch2_trans_iter_exit(trans, &iter);
 790         return ret;
 791 }
 792
 793 int bch2_snapshot_get_subvol(struct btree_trans *trans, u32 snapshot,
 794                              struct bch_subvolume *subvol)
 795 {
 796         struct bch_snapshot snap;
 797
 798         return  snapshot_lookup(trans, snapshot, &snap) ?:
 799                 bch2_subvolume_get(trans, le32_to_cpu(snap.subvol), true, 0, subvol);
 800 }
 801
 802 int bch2_subvolume_get_snapshot(struct btree_trans *trans, u32 subvol,
 803                                 u32 *snapid)
 804 {
 805         struct bch_subvolume s;
 806         int ret;
 807
 808         ret = bch2_subvolume_get(trans, subvol, true,
 809                                  BTREE_ITER_CACHED|
 810                                  BTREE_ITER_WITH_UPDATES,
 811                                  &s);
 812
 813         *snapid = le32_to_cpu(s.snapshot);
 814         return ret;
 815 }
 816
 817 /*
 818  * Delete subvolume, mark snapshot ID as deleted, queue up snapshot
 819  * deletion/cleanup:
 820  */
 821 int bch2_subvolume_delete(struct btree_trans *trans, u32 subvolid)
 822 {
 823         struct btree_iter iter;
 824         struct bkey_s_c k;
 825         struct bkey_s_c_subvolume subvol;
 826         struct btree_trans_commit_hook *h;
 827         struct bkey_i *delete;
 828         u32 snapid;
 829         int ret = 0;
 830
 831         bch2_trans_iter_init(trans, &iter, BTREE_ID_subvolumes,
 832                              POS(0, subvolid),
 833                              BTREE_ITER_CACHED|
 834                              BTREE_ITER_INTENT);
 835         k = bch2_btree_iter_peek_slot(&iter);
 836         ret = bkey_err(k);
 837         if (ret)
 838                 goto err;
 839
 840         if (k.k->type != KEY_TYPE_subvolume) {
 841                 bch2_fs_inconsistent(trans->c, "missing subvolume %u", subvolid);
 842                 ret = -EIO;
 843                 goto err;
 844         }
 845
 846         subvol = bkey_s_c_to_subvolume(k);
 847         snapid = le32_to_cpu(subvol.v->snapshot);
 848
 849         delete = bch2_trans_kmalloc(trans, sizeof(*delete));
 850         ret = PTR_ERR_OR_ZERO(delete);
 851         if (ret)
 852                 goto err;
 853
 854         bkey_init(&delete->k);
 855         delete->k.p = iter.pos;
 856         ret = bch2_trans_update(trans, &iter, delete, 0);
 857         if (ret)
 858                 goto err;
 859
 860         ret = bch2_snapshot_node_set_deleted(trans, snapid);
 861
 862         h = bch2_trans_kmalloc(trans, sizeof(*h));
 863         ret = PTR_ERR_OR_ZERO(h);
 864         if (ret)
 865                 goto err;
 866
 867         h->fn = bch2_delete_dead_snapshots_hook;
 868         bch2_trans_commit_hook(trans, h);
 869 err:
 870         bch2_trans_iter_exit(trans, &iter);
 871         return ret;
 872 }
 873
 874 void bch2_subvolume_wait_for_pagecache_and_delete(struct work_struct *work)
 875 {
 876         struct bch_fs *c = container_of(work, struct bch_fs,
 877                                 snapshot_wait_for_pagecache_and_delete_work);
 878         struct snapshot_id_list s;
 879         u32 *id;
 880         int ret = 0;
 881
 882         while (!ret) {
 883                 mutex_lock(&c->snapshots_unlinked_lock);
 884                 s = c->snapshots_unlinked;
 885                 memset(&c->snapshots_unlinked, 0, sizeof(c->snapshots_unlinked));
 886                 mutex_unlock(&c->snapshots_unlinked_lock);
 887
 888                 if (!s.nr)
 889                         break;
 890
 891                 bch2_evict_subvolume_inodes(c, &s);
 892
 893                 for (id = s.d; id < s.d + s.nr; id++) {
 894                         ret = bch2_trans_do(c, NULL, NULL, BTREE_INSERT_NOFAIL,
 895                                       bch2_subvolume_delete(&trans, *id));
 896                         if (ret) {
 897                                 bch_err(c, "error %i deleting subvolume %u", ret, *id);
 898                                 break;
 899                         }
 900                 }
 901
 902                 kfree(s.d);
 903         }
 904
 905         percpu_ref_put(&c->writes);
 906 }
 907
 908 struct subvolume_unlink_hook {
 909         struct btree_trans_commit_hook  h;
 910         u32                             subvol;
 911 };
 912
 913 int bch2_subvolume_wait_for_pagecache_and_delete_hook(struct btree_trans *trans,
 914                                                       struct btree_trans_commit_hook *_h)
 915 {
 916         struct subvolume_unlink_hook *h = container_of(_h, struct subvolume_unlink_hook, h);
 917         struct bch_fs *c = trans->c;
 918         int ret = 0;
 919
 920         mutex_lock(&c->snapshots_unlinked_lock);
 921         if (!snapshot_list_has_id(&c->snapshots_unlinked, h->subvol))
 922                 ret = snapshot_id_add(&c->snapshots_unlinked, h->subvol);
 923         mutex_unlock(&c->snapshots_unlinked_lock);
 924
 925         if (ret)
 926                 return ret;
 927
 928         if (unlikely(!percpu_ref_tryget(&c->writes)))
 929                 return -EROFS;
 930
 931         if (!queue_work(system_long_wq, &c->snapshot_wait_for_pagecache_and_delete_work))
 932                 percpu_ref_put(&c->writes);
 933         return 0;
 934 }
 935
 936 int bch2_subvolume_unlink(struct btree_trans *trans, u32 subvolid)
 937 {
 938         struct btree_iter iter;
 939         struct bkey_s_c k;
 940         struct bkey_i_subvolume *n;
 941         struct subvolume_unlink_hook *h;
 942         int ret = 0;
 943
 944         bch2_trans_iter_init(trans, &iter, BTREE_ID_subvolumes,
 945                              POS(0, subvolid),
 946                              BTREE_ITER_CACHED|
 947                              BTREE_ITER_INTENT);
 948         k = bch2_btree_iter_peek_slot(&iter);
 949         ret = bkey_err(k);
 950         if (ret)
 951                 goto err;
 952
 953         if (k.k->type != KEY_TYPE_subvolume) {
 954                 bch2_fs_inconsistent(trans->c, "missing subvolume %u", subvolid);
 955                 ret = -EIO;
 956                 goto err;
 957         }
 958
 959         n = bch2_trans_kmalloc(trans, sizeof(*n));
 960         ret = PTR_ERR_OR_ZERO(n);
 961         if (ret)
 962                 goto err;
 963
 964         bkey_reassemble(&n->k_i, k);
 965         SET_BCH_SUBVOLUME_UNLINKED(&n->v, true);
 966
 967         ret = bch2_trans_update(trans, &iter, &n->k_i, 0);
 968         if (ret)
 969                 goto err;
 970
 971         h = bch2_trans_kmalloc(trans, sizeof(*h));
 972         ret = PTR_ERR_OR_ZERO(h);
 973         if (ret)
 974                 goto err;
 975
 976         h->h.fn         = bch2_subvolume_wait_for_pagecache_and_delete_hook;
 977         h->subvol       = subvolid;
 978         bch2_trans_commit_hook(trans, &h->h);
 979 err:
 980         bch2_trans_iter_exit(trans, &iter);
 981         return ret;
 982 }
 983
 984 int bch2_subvolume_create(struct btree_trans *trans, u64 inode,
 985                           u32 src_subvolid,
 986                           u32 *new_subvolid,
 987                           u32 *new_snapshotid,
 988                           bool ro)
 989 {
 990         struct bch_fs *c = trans->c;
 991         struct btree_iter dst_iter, src_iter = (struct btree_iter) { NULL };
 992         struct bkey_i_subvolume *new_subvol = NULL;
 993         struct bkey_i_subvolume *src_subvol = NULL;
 994         struct bkey_s_c k;
 995         u32 parent = 0, new_nodes[2], snapshot_subvols[2];
 996         int ret = 0;
 997
 998         for_each_btree_key(trans, dst_iter, BTREE_ID_subvolumes, SUBVOL_POS_MIN,
 999                            BTREE_ITER_SLOTS|BTREE_ITER_INTENT, k, ret) {
1000                 if (bkey_cmp(k.k->p, SUBVOL_POS_MAX) > 0)
1001                         break;
1002
1003                 /*
1004                  * bch2_subvolume_delete() doesn't flush the btree key cache -
1005                  * ideally it would but that's tricky
1006                  */
1007                 if (bkey_deleted(k.k) &&
1008                     !bch2_btree_key_cache_find(c, BTREE_ID_subvolumes, dst_iter.pos))
1009                         goto found_slot;
1010         }
1011
1012         if (!ret)
1013                 ret = -ENOSPC;
1014         goto err;
1015 found_slot:
1016         snapshot_subvols[0] = dst_iter.pos.offset;
1017         snapshot_subvols[1] = src_subvolid;
1018
1019         if (src_subvolid) {
1020                 /* Creating a snapshot: */
1021                 src_subvol = bch2_trans_kmalloc(trans, sizeof(*src_subvol));
1022                 ret = PTR_ERR_OR_ZERO(src_subvol);
1023                 if (ret)
1024                         goto err;
1025
1026                 bch2_trans_iter_init(trans, &src_iter, BTREE_ID_subvolumes,
1027                                      POS(0, src_subvolid),
1028                                      BTREE_ITER_CACHED|
1029                                      BTREE_ITER_INTENT);
1030                 k = bch2_btree_iter_peek_slot(&src_iter);
1031                 ret = bkey_err(k);
1032                 if (ret)
1033                         goto err;
1034
1035                 if (k.k->type != KEY_TYPE_subvolume) {
1036                         bch_err(c, "subvolume %u not found", src_subvolid);
1037                         ret = -ENOENT;
1038                         goto err;
1039                 }
1040
1041                 bkey_reassemble(&src_subvol->k_i, k);
1042                 parent = le32_to_cpu(src_subvol->v.snapshot);
1043         }
1044
1045         ret = bch2_snapshot_node_create(trans, parent, new_nodes,
1046                                         snapshot_subvols,
1047                                         src_subvolid ? 2 : 1);
1048         if (ret)
1049                 goto err;
1050
1051         if (src_subvolid) {
1052                 src_subvol->v.snapshot = cpu_to_le32(new_nodes[1]);
1053                 ret = bch2_trans_update(trans, &src_iter, &src_subvol->k_i, 0);
1054                 if (ret)
1055                         goto err;
1056         }
1057
1058         new_subvol = bch2_trans_kmalloc(trans, sizeof(*new_subvol));
1059         ret = PTR_ERR_OR_ZERO(new_subvol);
1060         if (ret)
1061                 goto err;
1062
1063         bkey_subvolume_init(&new_subvol->k_i);
1064         new_subvol->v.flags     = 0;
1065         new_subvol->v.snapshot  = cpu_to_le32(new_nodes[0]);
1066         new_subvol->v.inode     = cpu_to_le64(inode);
1067         SET_BCH_SUBVOLUME_RO(&new_subvol->v, ro);
1068         SET_BCH_SUBVOLUME_SNAP(&new_subvol->v, src_subvolid != 0);
1069         new_subvol->k.p         = dst_iter.pos;
1070         ret = bch2_trans_update(trans, &dst_iter, &new_subvol->k_i, 0);
1071         if (ret)
1072                 goto err;
1073
1074         *new_subvolid   = new_subvol->k.p.offset;
1075         *new_snapshotid = new_nodes[0];
1076 err:
1077         bch2_trans_iter_exit(trans, &src_iter);
1078         bch2_trans_iter_exit(trans, &dst_iter);
1079         return ret;
1080 }
1081
1082 int bch2_fs_subvolumes_init(struct bch_fs *c)
1083 {
1084         INIT_WORK(&c->snapshot_delete_work, bch2_delete_dead_snapshots_work);
1085         INIT_WORK(&c->snapshot_wait_for_pagecache_and_delete_work,
1086                   bch2_subvolume_wait_for_pagecache_and_delete);
1087         mutex_init(&c->snapshots_unlinked_lock);
1088         return 0;
1089 }