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