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

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #include "bcachefs.h"
   4 #include "btree_key_cache.h"
   5 #include "btree_write_buffer.h"
   6 #include "bkey_methods.h"
   7 #include "btree_update.h"
   8 #include "buckets.h"
   9 #include "error.h"
  10 #include "extents.h"
  11 #include "extent_update.h"
  12 #include "inode.h"
  13 #include "str_hash.h"
  14 #include "snapshot.h"
  15 #include "subvolume.h"
  16 #include "varint.h"
  17
  18 #include <linux/random.h>
  19
  20 #include <asm/unaligned.h>
  21
  22 const char * const bch2_inode_opts[] = {
  23 #define x(name, ...)    #name,
  24         BCH_INODE_OPTS()
  25 #undef  x
  26         NULL,
  27 };
  28
  29 static const u8 byte_table[8] = { 1, 2, 3, 4, 6, 8, 10, 13 };
  30
  31 static int inode_decode_field(const u8 *in, const u8 *end,
  32                               u64 out[2], unsigned *out_bits)
  33 {
  34         __be64 be[2] = { 0, 0 };
  35         unsigned bytes, shift;
  36         u8 *p;
  37
  38         if (in >= end)
  39                 return -1;
  40
  41         if (!*in)
  42                 return -1;
  43
  44         /*
  45          * position of highest set bit indicates number of bytes:
  46          * shift = number of bits to remove in high byte:
  47          */
  48         shift   = 8 - __fls(*in); /* 1 <= shift <= 8 */
  49         bytes   = byte_table[shift - 1];
  50
  51         if (in + bytes > end)
  52                 return -1;
  53
  54         p = (u8 *) be + 16 - bytes;
  55         memcpy(p, in, bytes);
  56         *p ^= (1 << 8) >> shift;
  57
  58         out[0] = be64_to_cpu(be[0]);
  59         out[1] = be64_to_cpu(be[1]);
  60         *out_bits = out[0] ? 64 + fls64(out[0]) : fls64(out[1]);
  61
  62         return bytes;
  63 }
  64
  65 static inline void bch2_inode_pack_inlined(struct bkey_inode_buf *packed,
  66                                            const struct bch_inode_unpacked *inode)
  67 {
  68         struct bkey_i_inode_v3 *k = &packed->inode;
  69         u8 *out = k->v.fields;
  70         u8 *end = (void *) &packed[1];
  71         u8 *last_nonzero_field = out;
  72         unsigned nr_fields = 0, last_nonzero_fieldnr = 0;
  73         unsigned bytes;
  74         int ret;
  75
  76         bkey_inode_v3_init(&packed->inode.k_i);
  77         packed->inode.k.p.offset        = inode->bi_inum;
  78         packed->inode.v.bi_journal_seq  = cpu_to_le64(inode->bi_journal_seq);
  79         packed->inode.v.bi_hash_seed    = inode->bi_hash_seed;
  80         packed->inode.v.bi_flags        = cpu_to_le64(inode->bi_flags);
  81         packed->inode.v.bi_sectors      = cpu_to_le64(inode->bi_sectors);
  82         packed->inode.v.bi_size         = cpu_to_le64(inode->bi_size);
  83         packed->inode.v.bi_version      = cpu_to_le64(inode->bi_version);
  84         SET_INODEv3_MODE(&packed->inode.v, inode->bi_mode);
  85         SET_INODEv3_FIELDS_START(&packed->inode.v, INODEv3_FIELDS_START_CUR);
  86
  87
  88 #define x(_name, _bits)                                                 \
  89         nr_fields++;                                                    \
  90                                                                         \
  91         if (inode->_name) {                                             \
  92                 ret = bch2_varint_encode_fast(out, inode->_name);       \
  93                 out += ret;                                             \
  94                                                                         \
  95                 if (_bits > 64)                                         \
  96                         *out++ = 0;                                     \
  97                                                                         \
  98                 last_nonzero_field = out;                               \
  99                 last_nonzero_fieldnr = nr_fields;                       \
 100         } else {                                                        \
 101                 *out++ = 0;                                             \
 102                                                                         \
 103                 if (_bits > 64)                                         \
 104                         *out++ = 0;                                     \
 105         }
 106
 107         BCH_INODE_FIELDS_v3()
 108 #undef  x
 109         BUG_ON(out > end);
 110
 111         out = last_nonzero_field;
 112         nr_fields = last_nonzero_fieldnr;
 113
 114         bytes = out - (u8 *) &packed->inode.v;
 115         set_bkey_val_bytes(&packed->inode.k, bytes);
 116         memset_u64s_tail(&packed->inode.v, 0, bytes);
 117
 118         SET_INODEv3_NR_FIELDS(&k->v, nr_fields);
 119
 120         if (IS_ENABLED(CONFIG_BCACHEFS_DEBUG)) {
 121                 struct bch_inode_unpacked unpacked;
 122
 123                 int ret = bch2_inode_unpack(bkey_i_to_s_c(&packed->inode.k_i),
 124                                            &unpacked);
 125                 BUG_ON(ret);
 126                 BUG_ON(unpacked.bi_inum         != inode->bi_inum);
 127                 BUG_ON(unpacked.bi_hash_seed    != inode->bi_hash_seed);
 128                 BUG_ON(unpacked.bi_sectors      != inode->bi_sectors);
 129                 BUG_ON(unpacked.bi_size         != inode->bi_size);
 130                 BUG_ON(unpacked.bi_version      != inode->bi_version);
 131                 BUG_ON(unpacked.bi_mode         != inode->bi_mode);
 132
 133 #define x(_name, _bits) if (unpacked._name != inode->_name)             \
 134                         panic("unpacked %llu should be %llu",           \
 135                               (u64) unpacked._name, (u64) inode->_name);
 136                 BCH_INODE_FIELDS_v3()
 137 #undef  x
 138         }
 139 }
 140
 141 void bch2_inode_pack(struct bkey_inode_buf *packed,
 142                      const struct bch_inode_unpacked *inode)
 143 {
 144         bch2_inode_pack_inlined(packed, inode);
 145 }
 146
 147 static noinline int bch2_inode_unpack_v1(struct bkey_s_c_inode inode,
 148                                 struct bch_inode_unpacked *unpacked)
 149 {
 150         const u8 *in = inode.v->fields;
 151         const u8 *end = bkey_val_end(inode);
 152         u64 field[2];
 153         unsigned fieldnr = 0, field_bits;
 154         int ret;
 155
 156 #define x(_name, _bits)                                 \
 157         if (fieldnr++ == INODE_NR_FIELDS(inode.v)) {                    \
 158                 unsigned offset = offsetof(struct bch_inode_unpacked, _name);\
 159                 memset((void *) unpacked + offset, 0,                   \
 160                        sizeof(*unpacked) - offset);                     \
 161                 return 0;                                               \
 162         }                                                               \
 163                                                                         \
 164         ret = inode_decode_field(in, end, field, &field_bits);          \
 165         if (ret < 0)                                                    \
 166                 return ret;                                             \
 167                                                                         \
 168         if (field_bits > sizeof(unpacked->_name) * 8)                   \
 169                 return -1;                                              \
 170                                                                         \
 171         unpacked->_name = field[1];                                     \
 172         in += ret;
 173
 174         BCH_INODE_FIELDS_v2()
 175 #undef  x
 176
 177         /* XXX: signal if there were more fields than expected? */
 178         return 0;
 179 }
 180
 181 static int bch2_inode_unpack_v2(struct bch_inode_unpacked *unpacked,
 182                                 const u8 *in, const u8 *end,
 183                                 unsigned nr_fields)
 184 {
 185         unsigned fieldnr = 0;
 186         int ret;
 187         u64 v[2];
 188
 189 #define x(_name, _bits)                                                 \
 190         if (fieldnr < nr_fields) {                                      \
 191                 ret = bch2_varint_decode_fast(in, end, &v[0]);          \
 192                 if (ret < 0)                                            \
 193                         return ret;                                     \
 194                 in += ret;                                              \
 195                                                                         \
 196                 if (_bits > 64) {                                       \
 197                         ret = bch2_varint_decode_fast(in, end, &v[1]);  \
 198                         if (ret < 0)                                    \
 199                                 return ret;                             \
 200                         in += ret;                                      \
 201                 } else {                                                \
 202                         v[1] = 0;                                       \
 203                 }                                                       \
 204         } else {                                                        \
 205                 v[0] = v[1] = 0;                                        \
 206         }                                                               \
 207                                                                         \
 208         unpacked->_name = v[0];                                         \
 209         if (v[1] || v[0] != unpacked->_name)                            \
 210                 return -1;                                              \
 211         fieldnr++;
 212
 213         BCH_INODE_FIELDS_v2()
 214 #undef  x
 215
 216         /* XXX: signal if there were more fields than expected? */
 217         return 0;
 218 }
 219
 220 static int bch2_inode_unpack_v3(struct bkey_s_c k,
 221                                 struct bch_inode_unpacked *unpacked)
 222 {
 223         struct bkey_s_c_inode_v3 inode = bkey_s_c_to_inode_v3(k);
 224         const u8 *in = inode.v->fields;
 225         const u8 *end = bkey_val_end(inode);
 226         unsigned nr_fields = INODEv3_NR_FIELDS(inode.v);
 227         unsigned fieldnr = 0;
 228         int ret;
 229         u64 v[2];
 230
 231         unpacked->bi_inum       = inode.k->p.offset;
 232         unpacked->bi_journal_seq= le64_to_cpu(inode.v->bi_journal_seq);
 233         unpacked->bi_hash_seed  = inode.v->bi_hash_seed;
 234         unpacked->bi_flags      = le64_to_cpu(inode.v->bi_flags);
 235         unpacked->bi_sectors    = le64_to_cpu(inode.v->bi_sectors);
 236         unpacked->bi_size       = le64_to_cpu(inode.v->bi_size);
 237         unpacked->bi_version    = le64_to_cpu(inode.v->bi_version);
 238         unpacked->bi_mode       = INODEv3_MODE(inode.v);
 239
 240 #define x(_name, _bits)                                                 \
 241         if (fieldnr < nr_fields) {                                      \
 242                 ret = bch2_varint_decode_fast(in, end, &v[0]);          \
 243                 if (ret < 0)                                            \
 244                         return ret;                                     \
 245                 in += ret;                                              \
 246                                                                         \
 247                 if (_bits > 64) {                                       \
 248                         ret = bch2_varint_decode_fast(in, end, &v[1]);  \
 249                         if (ret < 0)                                    \
 250                                 return ret;                             \
 251                         in += ret;                                      \
 252                 } else {                                                \
 253                         v[1] = 0;                                       \
 254                 }                                                       \
 255         } else {                                                        \
 256                 v[0] = v[1] = 0;                                        \
 257         }                                                               \
 258                                                                         \
 259         unpacked->_name = v[0];                                         \
 260         if (v[1] || v[0] != unpacked->_name)                            \
 261                 return -1;                                              \
 262         fieldnr++;
 263
 264         BCH_INODE_FIELDS_v3()
 265 #undef  x
 266
 267         /* XXX: signal if there were more fields than expected? */
 268         return 0;
 269 }
 270
 271 static noinline int bch2_inode_unpack_slowpath(struct bkey_s_c k,
 272                                                struct bch_inode_unpacked *unpacked)
 273 {
 274         memset(unpacked, 0, sizeof(*unpacked));
 275
 276         switch (k.k->type) {
 277         case KEY_TYPE_inode: {
 278                 struct bkey_s_c_inode inode = bkey_s_c_to_inode(k);
 279
 280                 unpacked->bi_inum       = inode.k->p.offset;
 281                 unpacked->bi_journal_seq= 0;
 282                 unpacked->bi_hash_seed  = inode.v->bi_hash_seed;
 283                 unpacked->bi_flags      = le32_to_cpu(inode.v->bi_flags);
 284                 unpacked->bi_mode       = le16_to_cpu(inode.v->bi_mode);
 285
 286                 if (INODE_NEW_VARINT(inode.v)) {
 287                         return bch2_inode_unpack_v2(unpacked, inode.v->fields,
 288                                                     bkey_val_end(inode),
 289                                                     INODE_NR_FIELDS(inode.v));
 290                 } else {
 291                         return bch2_inode_unpack_v1(inode, unpacked);
 292                 }
 293                 break;
 294         }
 295         case KEY_TYPE_inode_v2: {
 296                 struct bkey_s_c_inode_v2 inode = bkey_s_c_to_inode_v2(k);
 297
 298                 unpacked->bi_inum       = inode.k->p.offset;
 299                 unpacked->bi_journal_seq= le64_to_cpu(inode.v->bi_journal_seq);
 300                 unpacked->bi_hash_seed  = inode.v->bi_hash_seed;
 301                 unpacked->bi_flags      = le64_to_cpu(inode.v->bi_flags);
 302                 unpacked->bi_mode       = le16_to_cpu(inode.v->bi_mode);
 303
 304                 return bch2_inode_unpack_v2(unpacked, inode.v->fields,
 305                                             bkey_val_end(inode),
 306                                             INODEv2_NR_FIELDS(inode.v));
 307         }
 308         default:
 309                 BUG();
 310         }
 311 }
 312
 313 int bch2_inode_unpack(struct bkey_s_c k,
 314                       struct bch_inode_unpacked *unpacked)
 315 {
 316         if (likely(k.k->type == KEY_TYPE_inode_v3))
 317                 return bch2_inode_unpack_v3(k, unpacked);
 318         return bch2_inode_unpack_slowpath(k, unpacked);
 319 }
 320
 321 int bch2_inode_peek(struct btree_trans *trans,
 322                     struct btree_iter *iter,
 323                     struct bch_inode_unpacked *inode,
 324                     subvol_inum inum, unsigned flags)
 325 {
 326         struct bkey_s_c k;
 327         u32 snapshot;
 328         int ret;
 329
 330         ret = bch2_subvolume_get_snapshot(trans, inum.subvol, &snapshot);
 331         if (ret)
 332                 return ret;
 333
 334         k = bch2_bkey_get_iter(trans, iter, BTREE_ID_inodes,
 335                                SPOS(0, inum.inum, snapshot),
 336                                flags|BTREE_ITER_CACHED);
 337         ret = bkey_err(k);
 338         if (ret)
 339                 return ret;
 340
 341         ret = bkey_is_inode(k.k) ? 0 : -BCH_ERR_ENOENT_inode;
 342         if (ret)
 343                 goto err;
 344
 345         ret = bch2_inode_unpack(k, inode);
 346         if (ret)
 347                 goto err;
 348
 349         return 0;
 350 err:
 351         bch2_trans_iter_exit(trans, iter);
 352         if (!bch2_err_matches(ret, BCH_ERR_transaction_restart))
 353                 bch_err_msg(trans->c, ret, "looking up inum %u:%llu:", inum.subvol, inum.inum);
 354         return ret;
 355 }
 356
 357 int bch2_inode_write(struct btree_trans *trans,
 358                      struct btree_iter *iter,
 359                      struct bch_inode_unpacked *inode)
 360 {
 361         struct bkey_inode_buf *inode_p;
 362
 363         inode_p = bch2_trans_kmalloc(trans, sizeof(*inode_p));
 364         if (IS_ERR(inode_p))
 365                 return PTR_ERR(inode_p);
 366
 367         bch2_inode_pack_inlined(inode_p, inode);
 368         inode_p->inode.k.p.snapshot = iter->snapshot;
 369         return bch2_trans_update(trans, iter, &inode_p->inode.k_i, 0);
 370 }
 371
 372 struct bkey_i *bch2_inode_to_v3(struct btree_trans *trans, struct bkey_i *k)
 373 {
 374         struct bch_inode_unpacked u;
 375         struct bkey_inode_buf *inode_p;
 376         int ret;
 377
 378         if (!bkey_is_inode(&k->k))
 379                 return ERR_PTR(-ENOENT);
 380
 381         inode_p = bch2_trans_kmalloc(trans, sizeof(*inode_p));
 382         if (IS_ERR(inode_p))
 383                 return ERR_CAST(inode_p);
 384
 385         ret = bch2_inode_unpack(bkey_i_to_s_c(k), &u);
 386         if (ret)
 387                 return ERR_PTR(ret);
 388
 389         bch2_inode_pack(inode_p, &u);
 390         return &inode_p->inode.k_i;
 391 }
 392
 393 static int __bch2_inode_invalid(struct bkey_s_c k, struct printbuf *err)
 394 {
 395         struct bch_inode_unpacked unpacked;
 396
 397         if (k.k->p.inode) {
 398                 prt_printf(err, "nonzero k.p.inode");
 399                 return -BCH_ERR_invalid_bkey;
 400         }
 401
 402         if (k.k->p.offset < BLOCKDEV_INODE_MAX) {
 403                 prt_printf(err, "fs inode in blockdev range");
 404                 return -BCH_ERR_invalid_bkey;
 405         }
 406
 407         if (bch2_inode_unpack(k, &unpacked)) {
 408                 prt_printf(err, "invalid variable length fields");
 409                 return -BCH_ERR_invalid_bkey;
 410         }
 411
 412         if (unpacked.bi_data_checksum >= BCH_CSUM_OPT_NR + 1) {
 413                 prt_printf(err, "invalid data checksum type (%u >= %u",
 414                         unpacked.bi_data_checksum, BCH_CSUM_OPT_NR + 1);
 415                 return -BCH_ERR_invalid_bkey;
 416         }
 417
 418         if (unpacked.bi_compression >= BCH_COMPRESSION_OPT_NR + 1) {
 419                 prt_printf(err, "invalid data checksum type (%u >= %u)",
 420                        unpacked.bi_compression, BCH_COMPRESSION_OPT_NR + 1);
 421                 return -BCH_ERR_invalid_bkey;
 422         }
 423
 424         if ((unpacked.bi_flags & BCH_INODE_UNLINKED) &&
 425             unpacked.bi_nlink != 0) {
 426                 prt_printf(err, "flagged as unlinked but bi_nlink != 0");
 427                 return -BCH_ERR_invalid_bkey;
 428         }
 429
 430         if (unpacked.bi_subvol && !S_ISDIR(unpacked.bi_mode)) {
 431                 prt_printf(err, "subvolume root but not a directory");
 432                 return -BCH_ERR_invalid_bkey;
 433         }
 434
 435         return 0;
 436 }
 437
 438 int bch2_inode_invalid(const struct bch_fs *c, struct bkey_s_c k,
 439                        enum bkey_invalid_flags flags,
 440                        struct printbuf *err)
 441 {
 442         struct bkey_s_c_inode inode = bkey_s_c_to_inode(k);
 443
 444         if (INODE_STR_HASH(inode.v) >= BCH_STR_HASH_NR) {
 445                 prt_printf(err, "invalid str hash type (%llu >= %u)",
 446                        INODE_STR_HASH(inode.v), BCH_STR_HASH_NR);
 447                 return -BCH_ERR_invalid_bkey;
 448         }
 449
 450         return __bch2_inode_invalid(k, err);
 451 }
 452
 453 int bch2_inode_v2_invalid(const struct bch_fs *c, struct bkey_s_c k,
 454                           enum bkey_invalid_flags flags,
 455                           struct printbuf *err)
 456 {
 457         struct bkey_s_c_inode_v2 inode = bkey_s_c_to_inode_v2(k);
 458
 459         if (INODEv2_STR_HASH(inode.v) >= BCH_STR_HASH_NR) {
 460                 prt_printf(err, "invalid str hash type (%llu >= %u)",
 461                        INODEv2_STR_HASH(inode.v), BCH_STR_HASH_NR);
 462                 return -BCH_ERR_invalid_bkey;
 463         }
 464
 465         return __bch2_inode_invalid(k, err);
 466 }
 467
 468 int bch2_inode_v3_invalid(const struct bch_fs *c, struct bkey_s_c k,
 469                           enum bkey_invalid_flags flags,
 470                           struct printbuf *err)
 471 {
 472         struct bkey_s_c_inode_v3 inode = bkey_s_c_to_inode_v3(k);
 473
 474         if (INODEv3_FIELDS_START(inode.v) < INODEv3_FIELDS_START_INITIAL ||
 475             INODEv3_FIELDS_START(inode.v) > bkey_val_u64s(inode.k)) {
 476                 prt_printf(err, "invalid fields_start (got %llu, min %u max %zu)",
 477                        INODEv3_FIELDS_START(inode.v),
 478                        INODEv3_FIELDS_START_INITIAL,
 479                        bkey_val_u64s(inode.k));
 480                 return -BCH_ERR_invalid_bkey;
 481         }
 482
 483         if (INODEv3_STR_HASH(inode.v) >= BCH_STR_HASH_NR) {
 484                 prt_printf(err, "invalid str hash type (%llu >= %u)",
 485                        INODEv3_STR_HASH(inode.v), BCH_STR_HASH_NR);
 486                 return -BCH_ERR_invalid_bkey;
 487         }
 488
 489         return __bch2_inode_invalid(k, err);
 490 }
 491
 492 static void __bch2_inode_unpacked_to_text(struct printbuf *out,
 493                                           struct bch_inode_unpacked *inode)
 494 {
 495         prt_printf(out, "mode %o flags %x journal_seq %llu bi_size %llu bi_sectors %llu bi_version %llu",
 496                inode->bi_mode, inode->bi_flags,
 497                inode->bi_journal_seq,
 498                inode->bi_size,
 499                inode->bi_sectors,
 500                inode->bi_version);
 501
 502 #define x(_name, _bits)                                         \
 503         prt_printf(out, " "#_name " %llu", (u64) inode->_name);
 504         BCH_INODE_FIELDS_v3()
 505 #undef  x
 506 }
 507
 508 void bch2_inode_unpacked_to_text(struct printbuf *out, struct bch_inode_unpacked *inode)
 509 {
 510         prt_printf(out, "inum: %llu ", inode->bi_inum);
 511         __bch2_inode_unpacked_to_text(out, inode);
 512 }
 513
 514 void bch2_inode_to_text(struct printbuf *out, struct bch_fs *c, struct bkey_s_c k)
 515 {
 516         struct bch_inode_unpacked inode;
 517
 518         if (bch2_inode_unpack(k, &inode)) {
 519                 prt_printf(out, "(unpack error)");
 520                 return;
 521         }
 522
 523         __bch2_inode_unpacked_to_text(out, &inode);
 524 }
 525
 526 static inline u64 bkey_inode_flags(struct bkey_s_c k)
 527 {
 528         switch (k.k->type) {
 529         case KEY_TYPE_inode:
 530                 return le32_to_cpu(bkey_s_c_to_inode(k).v->bi_flags);
 531         case KEY_TYPE_inode_v2:
 532                 return le64_to_cpu(bkey_s_c_to_inode_v2(k).v->bi_flags);
 533         case KEY_TYPE_inode_v3:
 534                 return le64_to_cpu(bkey_s_c_to_inode_v3(k).v->bi_flags);
 535         default:
 536                 return 0;
 537         }
 538 }
 539
 540 static inline bool bkey_is_deleted_inode(struct bkey_s_c k)
 541 {
 542         return bkey_inode_flags(k) & BCH_INODE_UNLINKED;
 543 }
 544
 545 int bch2_trans_mark_inode(struct btree_trans *trans,
 546                           enum btree_id btree_id, unsigned level,
 547                           struct bkey_s_c old,
 548                           struct bkey_i *new,
 549                           unsigned flags)
 550 {
 551         int nr = bkey_is_inode(&new->k) - bkey_is_inode(old.k);
 552         bool old_deleted = bkey_is_deleted_inode(old);
 553         bool new_deleted = bkey_is_deleted_inode(bkey_i_to_s_c(new));
 554
 555         if (nr) {
 556                 int ret = bch2_replicas_deltas_realloc(trans, 0);
 557                 struct replicas_delta_list *d = trans->fs_usage_deltas;
 558
 559                 if (ret)
 560                         return ret;
 561
 562                 d->nr_inodes += nr;
 563         }
 564
 565         if (old_deleted != new_deleted) {
 566                 int ret = bch2_btree_bit_mod(trans, BTREE_ID_deleted_inodes, new->k.p, new_deleted);
 567                 if (ret)
 568                         return ret;
 569         }
 570
 571         return 0;
 572 }
 573
 574 int bch2_mark_inode(struct btree_trans *trans,
 575                     enum btree_id btree_id, unsigned level,
 576                     struct bkey_s_c old, struct bkey_s_c new,
 577                     unsigned flags)
 578 {
 579         struct bch_fs *c = trans->c;
 580         struct bch_fs_usage *fs_usage;
 581         u64 journal_seq = trans->journal_res.seq;
 582
 583         if (flags & BTREE_TRIGGER_INSERT) {
 584                 struct bch_inode_v3 *v = (struct bch_inode_v3 *) new.v;
 585
 586                 BUG_ON(!journal_seq);
 587                 BUG_ON(new.k->type != KEY_TYPE_inode_v3);
 588
 589                 v->bi_journal_seq = cpu_to_le64(journal_seq);
 590         }
 591
 592         if (flags & BTREE_TRIGGER_GC) {
 593                 percpu_down_read(&c->mark_lock);
 594                 preempt_disable();
 595
 596                 fs_usage = fs_usage_ptr(c, journal_seq, flags & BTREE_TRIGGER_GC);
 597                 fs_usage->nr_inodes += bkey_is_inode(new.k);
 598                 fs_usage->nr_inodes -= bkey_is_inode(old.k);
 599
 600                 preempt_enable();
 601                 percpu_up_read(&c->mark_lock);
 602         }
 603         return 0;
 604 }
 605
 606 int bch2_inode_generation_invalid(const struct bch_fs *c, struct bkey_s_c k,
 607                                   enum bkey_invalid_flags flags,
 608                                   struct printbuf *err)
 609 {
 610         if (k.k->p.inode) {
 611                 prt_printf(err, "nonzero k.p.inode");
 612                 return -BCH_ERR_invalid_bkey;
 613         }
 614
 615         return 0;
 616 }
 617
 618 void bch2_inode_generation_to_text(struct printbuf *out, struct bch_fs *c,
 619                                    struct bkey_s_c k)
 620 {
 621         struct bkey_s_c_inode_generation gen = bkey_s_c_to_inode_generation(k);
 622
 623         prt_printf(out, "generation: %u", le32_to_cpu(gen.v->bi_generation));
 624 }
 625
 626 void bch2_inode_init_early(struct bch_fs *c,
 627                            struct bch_inode_unpacked *inode_u)
 628 {
 629         enum bch_str_hash_type str_hash =
 630                 bch2_str_hash_opt_to_type(c, c->opts.str_hash);
 631
 632         memset(inode_u, 0, sizeof(*inode_u));
 633
 634         /* ick */
 635         inode_u->bi_flags |= str_hash << INODE_STR_HASH_OFFSET;
 636         get_random_bytes(&inode_u->bi_hash_seed,
 637                          sizeof(inode_u->bi_hash_seed));
 638 }
 639
 640 void bch2_inode_init_late(struct bch_inode_unpacked *inode_u, u64 now,
 641                           uid_t uid, gid_t gid, umode_t mode, dev_t rdev,
 642                           struct bch_inode_unpacked *parent)
 643 {
 644         inode_u->bi_mode        = mode;
 645         inode_u->bi_uid         = uid;
 646         inode_u->bi_gid         = gid;
 647         inode_u->bi_dev         = rdev;
 648         inode_u->bi_atime       = now;
 649         inode_u->bi_mtime       = now;
 650         inode_u->bi_ctime       = now;
 651         inode_u->bi_otime       = now;
 652
 653         if (parent && parent->bi_mode & S_ISGID) {
 654                 inode_u->bi_gid = parent->bi_gid;
 655                 if (S_ISDIR(mode))
 656                         inode_u->bi_mode |= S_ISGID;
 657         }
 658
 659         if (parent) {
 660 #define x(_name, ...)   inode_u->bi_##_name = parent->bi_##_name;
 661                 BCH_INODE_OPTS()
 662 #undef x
 663         }
 664 }
 665
 666 void bch2_inode_init(struct bch_fs *c, struct bch_inode_unpacked *inode_u,
 667                      uid_t uid, gid_t gid, umode_t mode, dev_t rdev,
 668                      struct bch_inode_unpacked *parent)
 669 {
 670         bch2_inode_init_early(c, inode_u);
 671         bch2_inode_init_late(inode_u, bch2_current_time(c),
 672                              uid, gid, mode, rdev, parent);
 673 }
 674
 675 static inline u32 bkey_generation(struct bkey_s_c k)
 676 {
 677         switch (k.k->type) {
 678         case KEY_TYPE_inode:
 679         case KEY_TYPE_inode_v2:
 680                 BUG();
 681         case KEY_TYPE_inode_generation:
 682                 return le32_to_cpu(bkey_s_c_to_inode_generation(k).v->bi_generation);
 683         default:
 684                 return 0;
 685         }
 686 }
 687
 688 /*
 689  * This just finds an empty slot:
 690  */
 691 int bch2_inode_create(struct btree_trans *trans,
 692                       struct btree_iter *iter,
 693                       struct bch_inode_unpacked *inode_u,
 694                       u32 snapshot, u64 cpu)
 695 {
 696         struct bch_fs *c = trans->c;
 697         struct bkey_s_c k;
 698         u64 min, max, start, pos, *hint;
 699         int ret = 0;
 700         unsigned bits = (c->opts.inodes_32bit ? 31 : 63);
 701
 702         if (c->opts.shard_inode_numbers) {
 703                 bits -= c->inode_shard_bits;
 704
 705                 min = (cpu << bits);
 706                 max = (cpu << bits) | ~(ULLONG_MAX << bits);
 707
 708                 min = max_t(u64, min, BLOCKDEV_INODE_MAX);
 709                 hint = c->unused_inode_hints + cpu;
 710         } else {
 711                 min = BLOCKDEV_INODE_MAX;
 712                 max = ~(ULLONG_MAX << bits);
 713                 hint = c->unused_inode_hints;
 714         }
 715
 716         start = READ_ONCE(*hint);
 717
 718         if (start >= max || start < min)
 719                 start = min;
 720
 721         pos = start;
 722         bch2_trans_iter_init(trans, iter, BTREE_ID_inodes, POS(0, pos),
 723                              BTREE_ITER_ALL_SNAPSHOTS|
 724                              BTREE_ITER_INTENT);
 725 again:
 726         while ((k = bch2_btree_iter_peek(iter)).k &&
 727                !(ret = bkey_err(k)) &&
 728                bkey_lt(k.k->p, POS(0, max))) {
 729                 if (pos < iter->pos.offset)
 730                         goto found_slot;
 731
 732                 /*
 733                  * We don't need to iterate over keys in every snapshot once
 734                  * we've found just one:
 735                  */
 736                 pos = iter->pos.offset + 1;
 737                 bch2_btree_iter_set_pos(iter, POS(0, pos));
 738         }
 739
 740         if (!ret && pos < max)
 741                 goto found_slot;
 742
 743         if (!ret && start == min)
 744                 ret = -BCH_ERR_ENOSPC_inode_create;
 745
 746         if (ret) {
 747                 bch2_trans_iter_exit(trans, iter);
 748                 return ret;
 749         }
 750
 751         /* Retry from start */
 752         pos = start = min;
 753         bch2_btree_iter_set_pos(iter, POS(0, pos));
 754         goto again;
 755 found_slot:
 756         bch2_btree_iter_set_pos(iter, SPOS(0, pos, snapshot));
 757         k = bch2_btree_iter_peek_slot(iter);
 758         ret = bkey_err(k);
 759         if (ret) {
 760                 bch2_trans_iter_exit(trans, iter);
 761                 return ret;
 762         }
 763
 764         *hint                   = k.k->p.offset;
 765         inode_u->bi_inum        = k.k->p.offset;
 766         inode_u->bi_generation  = bkey_generation(k);
 767         return 0;
 768 }
 769
 770 static int bch2_inode_delete_keys(struct btree_trans *trans,
 771                                   subvol_inum inum, enum btree_id id)
 772 {
 773         struct btree_iter iter;
 774         struct bkey_s_c k;
 775         struct bkey_i delete;
 776         u32 snapshot;
 777         int ret = 0;
 778
 779         /*
 780          * We're never going to be deleting partial extents, no need to use an
 781          * extent iterator:
 782          */
 783         bch2_trans_iter_init(trans, &iter, id, POS(inum.inum, 0),
 784                              BTREE_ITER_INTENT|BTREE_ITER_NOT_EXTENTS);
 785
 786         while (1) {
 787                 bch2_trans_begin(trans);
 788
 789                 ret = bch2_subvolume_get_snapshot(trans, inum.subvol, &snapshot);
 790                 if (ret)
 791                         goto err;
 792
 793                 bch2_btree_iter_set_snapshot(&iter, snapshot);
 794
 795                 k = bch2_btree_iter_peek_upto(&iter, POS(inum.inum, U64_MAX));
 796                 ret = bkey_err(k);
 797                 if (ret)
 798                         goto err;
 799
 800                 if (!k.k)
 801                         break;
 802
 803                 bkey_init(&delete.k);
 804                 delete.k.p = iter.pos;
 805
 806                 ret = bch2_trans_update(trans, &iter, &delete, 0) ?:
 807                       bch2_trans_commit(trans, NULL, NULL,
 808                                         BTREE_INSERT_NOFAIL);
 809 err:
 810                 if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart))
 811                         break;
 812         }
 813
 814         bch2_trans_iter_exit(trans, &iter);
 815         return ret;
 816 }
 817
 818 int bch2_inode_rm(struct bch_fs *c, subvol_inum inum)
 819 {
 820         struct btree_trans trans;
 821         struct btree_iter iter = { NULL };
 822         struct bkey_i_inode_generation delete;
 823         struct bch_inode_unpacked inode_u;
 824         struct bkey_s_c k;
 825         u32 snapshot;
 826         int ret;
 827
 828         bch2_trans_init(&trans, c, 0, 1024);
 829
 830         /*
 831          * If this was a directory, there shouldn't be any real dirents left -
 832          * but there could be whiteouts (from hash collisions) that we should
 833          * delete:
 834          *
 835          * XXX: the dirent could ideally would delete whiteouts when they're no
 836          * longer needed
 837          */
 838         ret   = bch2_inode_delete_keys(&trans, inum, BTREE_ID_extents) ?:
 839                 bch2_inode_delete_keys(&trans, inum, BTREE_ID_xattrs) ?:
 840                 bch2_inode_delete_keys(&trans, inum, BTREE_ID_dirents);
 841         if (ret)
 842                 goto err;
 843 retry:
 844         bch2_trans_begin(&trans);
 845
 846         ret = bch2_subvolume_get_snapshot(&trans, inum.subvol, &snapshot);
 847         if (ret)
 848                 goto err;
 849
 850         k = bch2_bkey_get_iter(&trans, &iter, BTREE_ID_inodes,
 851                                SPOS(0, inum.inum, snapshot),
 852                                BTREE_ITER_INTENT|BTREE_ITER_CACHED);
 853         ret = bkey_err(k);
 854         if (ret)
 855                 goto err;
 856
 857         if (!bkey_is_inode(k.k)) {
 858                 bch2_fs_inconsistent(trans.c,
 859                                      "inode %llu:%u not found when deleting",
 860                                      inum.inum, snapshot);
 861                 ret = -EIO;
 862                 goto err;
 863         }
 864
 865         bch2_inode_unpack(k, &inode_u);
 866
 867         bkey_inode_generation_init(&delete.k_i);
 868         delete.k.p = iter.pos;
 869         delete.v.bi_generation = cpu_to_le32(inode_u.bi_generation + 1);
 870
 871         ret   = bch2_trans_update(&trans, &iter, &delete.k_i, 0) ?:
 872                 bch2_trans_commit(&trans, NULL, NULL,
 873                                 BTREE_INSERT_NOFAIL);
 874 err:
 875         bch2_trans_iter_exit(&trans, &iter);
 876         if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
 877                 goto retry;
 878
 879         bch2_trans_exit(&trans);
 880         return ret;
 881 }
 882
 883 int bch2_inode_find_by_inum_trans(struct btree_trans *trans,
 884                                   subvol_inum inum,
 885                                   struct bch_inode_unpacked *inode)
 886 {
 887         struct btree_iter iter;
 888         int ret;
 889
 890         ret = bch2_inode_peek(trans, &iter, inode, inum, 0);
 891         if (!ret)
 892                 bch2_trans_iter_exit(trans, &iter);
 893         return ret;
 894 }
 895
 896 int bch2_inode_find_by_inum(struct bch_fs *c, subvol_inum inum,
 897                             struct bch_inode_unpacked *inode)
 898 {
 899         return bch2_trans_do(c, NULL, NULL, 0,
 900                 bch2_inode_find_by_inum_trans(&trans, inum, inode));
 901 }
 902
 903 int bch2_inode_nlink_inc(struct bch_inode_unpacked *bi)
 904 {
 905         if (bi->bi_flags & BCH_INODE_UNLINKED)
 906                 bi->bi_flags &= ~BCH_INODE_UNLINKED;
 907         else {
 908                 if (bi->bi_nlink == U32_MAX)
 909                         return -EINVAL;
 910
 911                 bi->bi_nlink++;
 912         }
 913
 914         return 0;
 915 }
 916
 917 void bch2_inode_nlink_dec(struct btree_trans *trans, struct bch_inode_unpacked *bi)
 918 {
 919         if (bi->bi_nlink && (bi->bi_flags & BCH_INODE_UNLINKED)) {
 920                 bch2_trans_inconsistent(trans, "inode %llu unlinked but link count nonzero",
 921                                         bi->bi_inum);
 922                 return;
 923         }
 924
 925         if (bi->bi_flags & BCH_INODE_UNLINKED) {
 926                 bch2_trans_inconsistent(trans, "inode %llu link count underflow", bi->bi_inum);
 927                 return;
 928         }
 929
 930         if (bi->bi_nlink)
 931                 bi->bi_nlink--;
 932         else
 933                 bi->bi_flags |= BCH_INODE_UNLINKED;
 934 }
 935
 936 struct bch_opts bch2_inode_opts_to_opts(struct bch_inode_unpacked *inode)
 937 {
 938         struct bch_opts ret = { 0 };
 939 #define x(_name, _bits)                                                 \
 940         if (inode->bi_##_name)                                          \
 941                 opt_set(ret, _name, inode->bi_##_name - 1);
 942         BCH_INODE_OPTS()
 943 #undef x
 944         return ret;
 945 }
 946
 947 void bch2_inode_opts_get(struct bch_io_opts *opts, struct bch_fs *c,
 948                          struct bch_inode_unpacked *inode)
 949 {
 950 #define x(_name, _bits)         opts->_name = inode_opt_get(c, inode, _name);
 951         BCH_INODE_OPTS()
 952 #undef x
 953
 954         if (opts->nocow)
 955                 opts->compression = opts->background_compression = opts->data_checksum = opts->erasure_code = 0;
 956 }
 957
 958 int bch2_inode_rm_snapshot(struct btree_trans *trans, u64 inum, u32 snapshot)
 959 {
 960         struct bch_fs *c = trans->c;
 961         struct btree_iter iter = { NULL };
 962         struct bkey_i_inode_generation delete;
 963         struct bch_inode_unpacked inode_u;
 964         struct bkey_s_c k;
 965         int ret;
 966
 967         do {
 968                 ret   = bch2_btree_delete_range_trans(trans, BTREE_ID_extents,
 969                                                       SPOS(inum, 0, snapshot),
 970                                                       SPOS(inum, U64_MAX, snapshot),
 971                                                       0, NULL) ?:
 972                         bch2_btree_delete_range_trans(trans, BTREE_ID_dirents,
 973                                                       SPOS(inum, 0, snapshot),
 974                                                       SPOS(inum, U64_MAX, snapshot),
 975                                                       0, NULL) ?:
 976                         bch2_btree_delete_range_trans(trans, BTREE_ID_xattrs,
 977                                                       SPOS(inum, 0, snapshot),
 978                                                       SPOS(inum, U64_MAX, snapshot),
 979                                                       0, NULL);
 980         } while (ret == -BCH_ERR_transaction_restart_nested);
 981         if (ret)
 982                 goto err;
 983 retry:
 984         bch2_trans_begin(trans);
 985
 986         k = bch2_bkey_get_iter(trans, &iter, BTREE_ID_inodes,
 987                                SPOS(0, inum, snapshot), BTREE_ITER_INTENT);
 988         ret = bkey_err(k);
 989         if (ret)
 990                 goto err;
 991
 992         if (!bkey_is_inode(k.k)) {
 993                 bch2_fs_inconsistent(c,
 994                                      "inode %llu:%u not found when deleting",
 995                                      inum, snapshot);
 996                 ret = -EIO;
 997                 goto err;
 998         }
 999
1000         bch2_inode_unpack(k, &inode_u);
1001
1002         /* Subvolume root? */
1003         if (inode_u.bi_subvol)
1004                 bch_warn(c, "deleting inode %llu marked as unlinked, but also a subvolume root!?", inode_u.bi_inum);
1005
1006         bkey_inode_generation_init(&delete.k_i);
1007         delete.k.p = iter.pos;
1008         delete.v.bi_generation = cpu_to_le32(inode_u.bi_generation + 1);
1009
1010         ret   = bch2_trans_update(trans, &iter, &delete.k_i, 0) ?:
1011                 bch2_trans_commit(trans, NULL, NULL,
1012                                 BTREE_INSERT_NOFAIL);
1013 err:
1014         bch2_trans_iter_exit(trans, &iter);
1015         if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
1016                 goto retry;
1017
1018         return ret ?: -BCH_ERR_transaction_restart_nested;
1019 }
1020
1021 static int may_delete_deleted_inode(struct btree_trans *trans, struct bpos pos)
1022 {
1023         struct bch_fs *c = trans->c;
1024         struct btree_iter iter;
1025         struct bkey_s_c k;
1026         struct bch_inode_unpacked inode;
1027         int ret;
1028
1029         if (bch2_snapshot_is_internal_node(c, pos.snapshot))
1030                 return 0;
1031
1032         if (!fsck_err_on(c->sb.clean, c,
1033                          "filesystem marked as clean but have deleted inode %llu:%u",
1034                          pos.offset, pos.snapshot))
1035                 return 0;
1036
1037         k = bch2_bkey_get_iter(trans, &iter, BTREE_ID_inodes, pos, BTREE_ITER_CACHED);
1038         ret = bkey_err(k);
1039         if (ret)
1040                 return ret;
1041
1042         ret = bkey_is_inode(k.k) ? 0 : -BCH_ERR_ENOENT_inode;
1043         if (fsck_err_on(!bkey_is_inode(k.k), c,
1044                         "nonexistent inode %llu:%u in deleted_inodes btree",
1045                         pos.offset, pos.snapshot))
1046                 goto delete;
1047
1048         ret = bch2_inode_unpack(k, &inode);
1049         if (ret)
1050                 goto err;
1051
1052         if (fsck_err_on(S_ISDIR(inode.bi_mode), c,
1053                         "directory %llu:%u in deleted_inodes btree",
1054                         pos.offset, pos.snapshot))
1055                 goto delete;
1056
1057         if (fsck_err_on(!(inode.bi_flags & BCH_INODE_UNLINKED), c,
1058                         "non-deleted inode %llu:%u in deleted_inodes btree",
1059                         pos.offset, pos.snapshot))
1060                 goto delete;
1061
1062         return 1;
1063 err:
1064 fsck_err:
1065         return ret;
1066 delete:
1067         return bch2_btree_bit_mod(trans, BTREE_ID_deleted_inodes, pos, false);
1068 }
1069
1070 int bch2_delete_dead_inodes(struct bch_fs *c)
1071 {
1072         struct btree_trans trans;
1073         struct btree_iter iter;
1074         struct bkey_s_c k;
1075         int ret;
1076
1077         bch2_trans_init(&trans, c, 0, 0);
1078
1079         ret = bch2_btree_write_buffer_flush_sync(&trans);
1080         if (ret)
1081                 goto err;
1082
1083         /*
1084          * Weird transaction restart handling here because on successful delete,
1085          * bch2_inode_rm_snapshot() will return a nested transaction restart,
1086          * but we can't retry because the btree write buffer won't have been
1087          * flushed and we'd spin:
1088          */
1089         for_each_btree_key(&trans, iter, BTREE_ID_deleted_inodes, POS_MIN,
1090                            BTREE_ITER_PREFETCH|BTREE_ITER_ALL_SNAPSHOTS, k, ret) {
1091                 ret = lockrestart_do(&trans, may_delete_deleted_inode(&trans, k.k->p));
1092                 if (ret < 0)
1093                         break;
1094
1095                 if (ret) {
1096                         if (!test_bit(BCH_FS_RW, &c->flags)) {
1097                                 bch2_trans_unlock(&trans);
1098                                 bch2_fs_lazy_rw(c);
1099                         }
1100
1101                         ret = bch2_inode_rm_snapshot(&trans, k.k->p.offset, k.k->p.snapshot);
1102                         if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart))
1103                                 break;
1104                 }
1105         }
1106         bch2_trans_iter_exit(&trans, &iter);
1107 err:
1108         bch2_trans_exit(&trans);
1109
1110         return ret;
1111 }