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