fs/bcachefs/subvolume.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _BCACHEFS_SUBVOLUME_H
   3 #define _BCACHEFS_SUBVOLUME_H
   4
   5 #include "darray.h"
   6 #include "subvolume_types.h"
   7
   8 enum bch_validate_flags;
   9
  10 int bch2_check_subvols(struct bch_fs *);
  11 int bch2_check_subvol_children(struct bch_fs *);
  12
  13 int bch2_subvolume_validate(struct bch_fs *, struct bkey_s_c, enum bch_validate_flags);
  14 void bch2_subvolume_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c);
  15 int bch2_subvolume_trigger(struct btree_trans *, enum btree_id, unsigned,
  16                            struct bkey_s_c, struct bkey_s,
  17                            enum btree_iter_update_trigger_flags);
  18
  19 #define bch2_bkey_ops_subvolume ((struct bkey_ops) {            \
  20         .key_validate   = bch2_subvolume_validate,              \
  21         .val_to_text    = bch2_subvolume_to_text,               \
  22         .trigger        = bch2_subvolume_trigger,               \
  23         .min_val_size   = 16,                                   \
  24 })
  25
  26 int bch2_subvol_has_children(struct btree_trans *, u32);
  27 int bch2_subvolume_get(struct btree_trans *, unsigned,
  28                        bool, int, struct bch_subvolume *);
  29 int __bch2_subvolume_get_snapshot(struct btree_trans *, u32,
  30                                   u32 *, bool);
  31 int bch2_subvolume_get_snapshot(struct btree_trans *, u32, u32 *);
  32
  33 int bch2_subvol_is_ro_trans(struct btree_trans *, u32);
  34 int bch2_subvol_is_ro(struct bch_fs *, u32);
  35
  36 static inline struct bkey_s_c
  37 bch2_btree_iter_peek_in_subvolume_upto_type(struct btree_iter *iter, struct bpos end,
  38                                             u32 subvolid, unsigned flags)
  39 {
  40         u32 snapshot;
  41         int ret = bch2_subvolume_get_snapshot(iter->trans, subvolid, &snapshot);
  42         if (ret)
  43                 return bkey_s_c_err(ret);
  44
  45         bch2_btree_iter_set_snapshot(iter, snapshot);
  46         return bch2_btree_iter_peek_upto_type(iter, end, flags);
  47 }
  48
  49 #define for_each_btree_key_in_subvolume_upto_continue(_trans, _iter,            \
  50                                          _end, _subvolid, _flags, _k, _do)      \
  51 ({                                                                              \
  52         struct bkey_s_c _k;                                                     \
  53         int _ret3 = 0;                                                          \
  54                                                                                 \
  55         do {                                                                    \
  56                 _ret3 = lockrestart_do(_trans, ({                               \
  57                         (_k) = bch2_btree_iter_peek_in_subvolume_upto_type(&(_iter),    \
  58                                                 _end, _subvolid, (_flags));     \
  59                         if (!(_k).k)                                            \
  60                                 break;                                          \
  61                                                                                 \
  62                         bkey_err(_k) ?: (_do);                                  \
  63                 }));                                                            \
  64         } while (!_ret3 && bch2_btree_iter_advance(&(_iter)));                  \
  65                                                                                 \
  66         bch2_trans_iter_exit((_trans), &(_iter));                               \
  67         _ret3;                                                                  \
  68 })
  69
  70 #define for_each_btree_key_in_subvolume_upto(_trans, _iter, _btree_id,          \
  71                                 _start, _end, _subvolid, _flags, _k, _do)       \
  72 ({                                                                              \
  73         struct btree_iter _iter;                                                \
  74         bch2_trans_iter_init((_trans), &(_iter), (_btree_id),                   \
  75                              (_start), (_flags));                               \
  76                                                                                 \
  77         for_each_btree_key_in_subvolume_upto_continue(_trans, _iter,            \
  78                                         _end, _subvolid, _flags, _k, _do);      \
  79 })
  80
  81 int bch2_delete_dead_snapshots(struct bch_fs *);
  82 void bch2_delete_dead_snapshots_async(struct bch_fs *);
  83
  84 int bch2_subvolume_unlink(struct btree_trans *, u32);
  85 int bch2_subvolume_create(struct btree_trans *, u64, u32, u32, u32 *, u32 *, bool);
  86
  87 int bch2_initialize_subvolumes(struct bch_fs *);
  88 int bch2_fs_upgrade_for_subvolumes(struct bch_fs *);
  89
  90 int bch2_fs_subvolumes_init(struct bch_fs *);
  91
  92 #endif /* _BCACHEFS_SUBVOLUME_H */