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